package com.ygxsk.carhome.utils;

import android.app.Activity;
import android.content.ClipData;
import android.content.ClipboardManager;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.graphics.Bitmap;
import android.graphics.Color;
import android.graphics.Typeface;
import android.graphics.drawable.BitmapDrawable;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import android.text.TextUtils;
import android.view.Gravity;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.webkit.CookieManager;
import android.widget.CompoundButton;
import android.widget.TextView;

import androidx.annotation.NonNull;
import androidx.core.content.ContextCompat;

import com.afollestad.materialdialogs.DialogAction;
import com.afollestad.materialdialogs.MaterialDialog;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.blankj.utilcode.util.ActivityUtils;
import com.blankj.utilcode.util.AppUtils;
import com.blankj.utilcode.util.ClickUtils;
import com.blankj.utilcode.util.ColorUtils;
import com.blankj.utilcode.util.DeviceUtils;
import com.blankj.utilcode.util.LogUtils;
import com.blankj.utilcode.util.NetworkUtils;
import com.blankj.utilcode.util.ObjectUtils;
import com.blankj.utilcode.util.PathUtils;
import com.blankj.utilcode.util.SPUtils;
import com.blankj.utilcode.util.ScreenUtils;
import com.blankj.utilcode.util.StringUtils;
import com.blankj.utilcode.util.TimeUtils;
import com.blankj.utilcode.util.ToastUtils;
import com.blankj.utilcode.util.Utils;
import com.blankj.utilcode.util.VibrateUtils;
import com.flyco.roundview.RoundTextView;
import com.lxj.xpopup.XPopup;
import com.lxj.xpopup.core.BasePopupView;
import com.lxj.xpopup.impl.ConfirmPopupView;
import com.lxj.xpopup.interfaces.OnConfirmListener;
import com.tencent.mmkv.MMKV;
import com.tencent.smtt.sdk.WebSettings;
import com.yanzhenjie.album.Album;
import com.yanzhenjie.album.api.widget.Widget;
import com.ygxsk.carhome.R;
import com.ygxsk.carhome.alertview.AlertView;
import com.ygxsk.carhome.alertview.OnItemClickListener;
import com.ygxsk.carhome.constant.ConstantApi;
import com.ygxsk.carhome.constant.ConstantSign;
import com.ygxsk.carhome.constant.ExtraKey;
import com.ygxsk.carhome.constant.ExtraValue;
import com.ygxsk.carhome.listener.AuthorityCallbackListener;
import com.ygxsk.carhome.listener.Delivery;
import com.ygxsk.carhome.listener.MianTaskManager;
import com.ygxsk.carhome.response.CarBrandLargeCategory;
import com.ygxsk.carhome.response.CarBrandSeriesLineSmallCategory;
import com.ygxsk.carhome.response.GoodsBean;
import com.ygxsk.carhome.response.ShopCartBean;
import com.ygxsk.carhome.response.SystemConfigEntity;
import com.ygxsk.carhome.retrofit.AddLogUpLoadInfo;
import com.ygxsk.carhome.retrofit.ApiException;
import com.ygxsk.carhome.retrofit.ApiRequestSubListener;
import com.ygxsk.carhome.retrofit.ApiService;
import com.ygxsk.carhome.retrofit.ErrorConsumer;
import com.ygxsk.carhome.retrofit.NetworkManager;
import com.ygxsk.carhome.retrofit.ResponseTransformAddLog;
import com.ygxsk.carhome.retrofit.ResponseTransformer;
import com.ygxsk.carhome.sys.Session;
import com.ygxsk.carhome.ui.BaseImmersionFragment;
import com.ygxsk.carhome.ui.ErrorActivity;
import com.ygxsk.carhome.ui.order.WebGoodDetaillActivity;
import com.ygxsk.carhome.ui.usercenter.AboutMeActivity;
import com.ygxsk.carhome.ui.usercenter.LoginCarActivity;
import com.ygxsk.carhome.ui.usercenter.WebViewAboriginalActivity;
import com.ygxsk.carhome.ui.usercenter.WebViewNormalActivity;
import com.ygxsk.integrated.retrofit.Parameterkey;

import java.io.File;
import java.math.BigDecimal;
import java.text.Collator;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers;
import io.reactivex.rxjava3.core.Observable;
import io.reactivex.rxjava3.core.ObservableSource;
import io.reactivex.rxjava3.functions.Consumer;
import io.reactivex.rxjava3.functions.Function;
import io.reactivex.rxjava3.functions.Predicate;
import okhttp3.MediaType;
import okhttp3.RequestBody;

public class CommUtils {


    /**
     * 这个仅仅是适用于登录弹窗内容
     */
    public static AlertView mAlertViewLogin;

    //在trycatch之中添加的报错
    public static void addLogTryCatch(Context _context, String _interfaceAddress, String _errorContent) {

        addLog(_context,//
                _interfaceAddress,//
                ConstantSign.REQUEST_METHOD_POST,//
                "",//
                _errorContent);//

    }

    /**
     * 添加上传错误报错日志的接口,正常的接口上使用的异常请求添加。
     */
    public static void addLog(Context _context,//上下文对象
                              String _interfaceAddress,//接口地址内容
                              String _requestMethod,//请求方式
                              String _requestParamJsonSring,//请求参数String _requestParam
                              String _errorContent) {//报错内容

        //-------------------------------------------------------------------------------------------------------

        //最好是趁着服务或者，可能是从服务里边传递过来的。
        Map<String, Object> mapFillParamDataForAddLog = new HashMap<>();


        if (!TextUtils.equals(_interfaceAddress, ConstantSign.INTERFACE_ADDRESS)) {

            //2021年2月1日13:44:25 设置为以2xxx开头的都是提示用户的都要屏蔽掉
            //错误的内容是：code=20002&message=无数据
            //这样做的目的是 给20401的也添加到日志管理中去，有的用户网络不好也会报错20401
        /*if (_errorContent.startsWith("code=2") && (!_errorContent.startsWith("code=20401"))) {//2开头的都不要。
            LogUtils.d("itchen----包含 无意义日志。--->" + _errorContent);
            return;
        }*/

            //LogUtils.d(ConstantApi.LOGCAT_NOMAL + "即将执行 1 次上传的操作--之后-PUBADDLOG_KEY_SINGLE值是=>" + MMKV.defaultMMKV().decodeInt(ConstantApi.PUBADDLOG_KEY_SINGLE));

            //执行完毕一次上传操作之后，对这个计数器+1操作。这样下次，就不走这个逻辑。
            //numberCounter = numberCounter + 1;  根据 addLogFormatCodeMessage 来的
            //========2022年11月10日21:01:20等将来项目稳定再去掉个=========================================================================================
            if (_errorContent.contains("20002")//
                    || _errorContent.contains("code=20003")//
                    || (_errorContent.contains("code=29999") && (_errorContent.contains("无更多数据")))) {//无数据也是无意义的，不提交

                //{"data":"","message":"无更多数据","code":"20003"}
                //{"data":"","message":"无数据","code":"20002"}
                //|| _errorContent.startsWith("code=29999")//
                //code=29999&message=无更多数据#inputBox=wanghui1#loginName=wanghui1#trueName=王晖
                //code=29999&message=不可操作任务执行状态为进行中的任务！#inputBox=13582113090#loginName=wangyuzhu#trueName=王玉柱

                //包含无意义的日志 也要放开日志开关，方便下一次上传日志。
                MMKV.defaultMMKV().putBoolean(ConstantSign.MMKV_ADDLOG_SUCCESSED, true);
//            LogUtils.d("itchen----包含 无意义日志。--->" + _errorContent);
                return;
            }

            //2023年1月13日15:18:11单独的将参数这个HashMap转换为json
            //=================================================================================================
            //最好是趁着服务或者，可能是从服务里边传递过来的。
            mapFillParamDataForAddLog.put("interfaceAddress", _interfaceAddress +//
                    "#inputBox=" + MMKV.defaultMMKV().decodeString(ConstantSign.P_INPUTNAMELASTTIME) +//用户输入的登录名
                    "#loginName=" + MMKV.defaultMMKV().decodeString(ConstantSign.P_LOGINNAME) + //2021-9-1新添加的
                    "#trueName=" + MMKV.defaultMMKV().decodeString(ConstantSign.P_TRUENAME));//接口地址
            //报错内容+loginName(文本输入的登录名)+trueName(真实的人员姓名)
            //LogUtils.d("itchen---接口地址-->" + _interfaceAddress);

            mapFillParamDataForAddLog.put("requestMethod", _requestMethod);//请求方式
            //LogUtils.d("itchen---请求方式-->" + _requestMethod);

            //多循环会出现在这个参数内，给它添加开关
//        if (MMKV.defaultMMKV().decodeBool(ConstantApi.MMKV_ADDLOG_SUCCESSED)) {
            //添加日志的时候尽量给日志requestParam去掉，免得有循环重复。
            //mapFillParamDataForAddLog.remove("requestParam");
            //mapFillParamDataForAddLog.put("requestParam", JSON.toJSONString(_requestParam));//请求参数
            mapFillParamDataForAddLog.put("requestParam", _requestParamJsonSring);//请求参数
            //LogUtils.d("itchen---请求参数-->" + _requestParam);
//        }

            mapFillParamDataForAddLog.put("errorContent", _errorContent);//

            //LogUtils.d("itchen---报错内容-->" + _errorContent);

            try {

                //do
                if (MMKV.defaultMMKV().decodeBool(ConstantSign.P_SECRECYTURL_AGREE)) {

                    mapFillParamDataForAddLog.put("phoneBrand", MMKV.defaultMMKV().decodeString(ConstantSign.MMKV_MANUFACTURER));//手机品牌
                    //LogUtils.d("itchen---手机厂商 品牌-->" + DeviceUtils.getManufacturer());
                    // itchen---手机厂商-->HUAWEI

                    mapFillParamDataForAddLog.put("phoneModel", MMKV.defaultMMKV().decodeString(ConstantSign.MMKV_MODEL));//手机型号
                    //LogUtils.d("itchen---手机型号-->" + DeviceUtils.getModel());
                    //itchen---手机型号-->DUK-AL20

                }

            } catch (Exception e) {
                //catch
                e.printStackTrace();
            }

            //额外添加信息--------------------------------------------------------------------------------------------------------------------
            mapFillParamDataForAddLog.put("phoneVersion", MMKV.defaultMMKV().decodeString(ConstantSign.MMKV_SDKVERSIONNAME) + //
                    "#sdkcode#" + MMKV.defaultMMKV().decodeInt(ConstantSign.MMKV_SDKVERSIONCODE) + //
                    "#" + MMKV.defaultMMKV().decodeInt(ConstantSign.MMKV_SCREENWIDTH) + //
                    "x" + MMKV.defaultMMKV().decodeInt(ConstantSign.MMKV_SCREENHEIGHT) + //
                    "#abis#" + MMKV.defaultMMKV().decodeString(ConstantSign.MMKV_ABIS) + //
                    "#" + MMKV.defaultMMKV().decodeInt(ConstantSign.MMKV_APPVERSIONCODE) + //
                    "#v" + MMKV.defaultMMKV().decodeString(ConstantSign.MMKV_APPVERSIONNAME));//手机系统版本//
            //"phoneVersion": "9#sdkcode#1#1080x2340#abis#arm64-v8a,armeabi-v7a,armeabi#61#v2.1.4",

            //请求时间:yyyy-MM-dd HH:mm:ss  这种格式：2020-12-19 10:59:41
            mapFillParamDataForAddLog.put("requestTime", TimeUtilSer.getNow());
            //LogUtils.d("itchen---当前请求时间-->" + TimeUtilSer.getNow());

        } else {

            //是崩溃信息的 日志接口
            //请求时间:yyyy-MM-dd HH:mm:ss  这种格式：2020-12-19 10:59:41
            //mapFillParamDataForAddLog.put("requestTime", TimeUtilSer.getNow());日志内携带有时间
            mapFillParamDataForAddLog.put("errorContent", _errorContent);//

        }

        //-------------------------------------------------------------------------------------------------------------------
        AddLogUpLoadInfo addLogUpLoadInfo = new AddLogUpLoadInfo();

        try {
            //do
            if (_context != null) {
                if (_context instanceof ErrorActivity) {
                    addLogUpLoadInfo.setActivity((Activity) _context);
                } else {
                    addLogUpLoadInfo.setActivity(null);//直接设置为空
                }
            } else {
                addLogUpLoadInfo.setActivity(null);//直接设置为空
            }

        } catch (Exception e) {
            //catch
            e.printStackTrace();
        }

        addLogUpLoadInfo.setWhat(ConstantApi.WHAT_ADDLOG);
        addLogUpLoadInfo.setUrlPath(ApiService.addLogUrl);
        addLogUpLoadInfo.setRequestMethod(ConstantSign.REQUEST_METHOD_POST);
        addLogUpLoadInfo.setToastToUser(false);//不需要展示给用户的
        addLogUpLoadInfo.setHashMapParameter((HashMap<String, Object>) mapFillParamDataForAddLog);

        //这里写单独的
        RequestBody requestBody = RequestBody.create(JSON.toJSONString(mapFillParamDataForAddLog, //
                SerializerFeature.PrettyFormat,//
                SerializerFeature.WriteMapNullValue), MediaType.parse(ApiService.HEADER_JSON));//
        //上传log;
        NetworkManager.getInstance().initRetrofitRxJava()//
                .create(ApiService.class)//
                .addLog(requestBody)//
                .compose(new ResponseTransformAddLog<>(addLogUpLoadInfo,//
                        new ApiRequestSubListener<String>() {
                            @Override
                            public void handlerSomeThingNotSuccessDataForItSelf(int what_method, String serverCode, String serverMessage) {
                                super.handlerSomeThingNotSuccessDataForItSelf(what_method, serverCode, serverMessage);
                                //super.onErrorServerNotSuccessDataResponse(method, isToastToUser, _activity, statusCode, message);
                                //这里做一些非20000的处理--日志这里暂时可能用不到；
                                MMKV.defaultMMKV().putBoolean(ConstantSign.MMKV_ADDLOG_SUCCESSED, false);
//                      LogUtils.d(ConstantApi.LOGCAT_NOMAL + "设置 上传日志的标志 为 false");

                            }
                        })).subscribe(new Consumer<String>() {
                    @Override
                    public void accept(String valueString) throws Exception {
                        //上传成功
                        MMKV.defaultMMKV().putBoolean(ConstantSign.MMKV_ADDLOG_SUCCESSED, true);
//                        LogUtils.d(ConstantApi.LOGCAT_NOMAL + "日志上传成功-立即变更状态-MMKV_ADDLOG_SUCCESSED->" + MMKV.defaultMMKV().decodeBool(ConstantApi.MMKV_ADDLOG_SUCCESSED));
                        //2022-11-16 bug-发现如果上传日志失败，就会一直上传，拦截日志，等到下次启动APP的时候重新设置为true,打开再次允许上传日志
                    }
                }, new ErrorConsumer() {

                    @Override
                    protected void error(ApiException e) {
                        // : 2022-10-26 20:19 上传日志处理 能走到这里 也设置 false 不让上传日志；
                        MMKV.defaultMMKV().putBoolean(ConstantSign.MMKV_ADDLOG_SUCCESSED, false);

                    }
                });


        //-------------------------------------------------------------------------------------------------------

    }

//    public static void finishAllActivity(Context context) {
//        MianTaskManager.getInstance(context).finishAllActivity();
//    }

    /**
     * 获取年月日，不带日期 例如：2023-10-16 00:00:00 转换为 2023-10-16
     *
     * @param originalTime
     * @return
     */
    public static String getTimeHasNoMMddss(String originalTime) {

        String resultDateHasNoMMddss = "";

        if (!TextUtils.isEmpty(originalTime)) {

            if (originalTime.length() > TimeUtilSer.simplemore.length()) {

//                LogUtils.d(ConstantSign.LOGCAT_NOMAL+"符合长度--"+TimeUtilSer.simplemore.length());
                // itchen-->符合长度--10
                Date date = TimeUtils.string2Date(originalTime);
                resultDateHasNoMMddss = TimeUtils.date2String(date, TimeUtilSer.simplemore);

            } else {
                //原本的样子返回去
                resultDateHasNoMMddss = originalTime;
            }
        }
        return resultDateHasNoMMddss;
    }


    public static final void setViewVisible(View view) {

        if (view != null) {
            if (view.getVisibility() == View.GONE || view.getVisibility() == View.INVISIBLE) {
                view.setVisibility(View.VISIBLE);
            }
            //LogUtils.d("itchenqi-------------------->展示view--------------------------------");
        }

    }

    public static final void setViewGone(View view) {

        if (view != null) {
            if (view.getVisibility() == View.VISIBLE) {
                view.setVisibility(View.GONE);
            }
        }
        //LogUtils.d("itchenqi-------------------->隐藏view----------------------------------");

    }

    public static final void setViewInvisible(View view) {

        if (view != null) {
            if (view.getVisibility() == View.VISIBLE) {
                view.setVisibility(View.INVISIBLE);
            }
        }
    }

    /**
     * 异常的日志内容
     */
    public static String addLogFormatException(Exception e) {
        //String clazzName, String localMessage
        if (!ObjectUtils.isEmpty(e)) {

            if (e instanceof ApiException) {
                //2022-1-10 14:17:49 如果要单独的对e进行拦截，其他特殊类型的异常，可以从这里过滤和拦截。
                return (e.getClass().getName().toString() + "&getLocalizedMessage=apiException=>" + ((ApiException) e).getDisplayMessage());
            } else {
                return (e.getClass().getName().toString() + "&getLocalizedMessage=>" + e.getLocalizedMessage());
            }
            //responseData.getMessage()=>nullallData=>HttpEntitySK{code='null', msg='null', data=null}
        }
        return "exception是null";
    }


    /**
     * @date 2018/4/10 0010
     * @auther itchenqi
     * @description 普通弹窗检测关闭
     */
    public static void checkDialog(AlertView mAlertView) {
        if (mAlertView != null) {
            if (mAlertView.isShowing()) {
                mAlertView.dismiss();
            }
        }
    }

    //关闭自定义的 BasePopupView 弹窗
    public static void checkBasePopupView(BasePopupView mAlertBasePopupView) {

        if (mAlertBasePopupView != null) {
            if (mAlertBasePopupView.isShow()) {
                mAlertBasePopupView.dismiss();
            }
            mAlertBasePopupView.onDestroy();
            mAlertBasePopupView = null;
        }

    }

    /**
     * 设置弹窗的内容
     */
    public static void checkMaterialDialog(MaterialDialog materialDialog) {

        if (materialDialog != null) {
            if (materialDialog.isShowing()) {
                materialDialog.dismiss();
            }
            if (!materialDialog.isCancelled()) {
                materialDialog.cancel();
            }
        }

        //直接重置为null
        materialDialog = null;

    }

    /**
     * 这里如果不是个性化的ApiRequestListener的话就直接使用本类之中的该方法
     */
    public static void onExceptionRequest(int method, Activity activity, Exception exception) {

//        if (exception instanceof NetworkError) {
//
//            ToastUtils.showShort("网络不可用，请检查网络");
//
//        } else if (exception instanceof URLError) {
//
//            ToastUtils.showShort("Url格式错误");
//
//        } else if (exception instanceof HostError) {
//
//            ToastUtils.showShort("没有找到Url指定的服务器");
//
//        } else if (exception instanceof ConnectTimeoutError) {
//
//            ToastUtils.showShort("连接服务器超时");
//
//        } else if (exception instanceof WriteException) {
//
//            ToastUtils.showShort("发送数据失败");
//
//        } else if (exception instanceof ReadTimeoutError) {
//
//            ToastUtils.showShort("读取数据超时");
//
//        } else {

        //发生未知异常 就给异常的信息 提示出来。
        if (!ObjectUtils.isEmpty(exception)) {
            ToastUtils.showShort("onExceptionRequest发生未知异常==>" + exception.getLocalizedMessage());
        } else {
            ToastUtils.showShort("onExceptionRequest发生未知异常~");
        }

        //LogUtils.d("itchen------>exception==>" + exception.getLocalizedMessage());
        //LogUtils.d("itchen------>exception222222==>" + exception.getMessage());
        //LogUtils.d("itchen------>exception33333==>" + exception.getCause().toString());

//        }

        //这个特殊和其他的 接口上的使用的上传日志不同
        //addLogonExceptionRequest(method, activity, exception);

    }


    /**
     * 获取程序的名字
     */
    public static String getAppName(Context context) {

        PackageManager pmanager = context.getPackageManager();


        try {
            PackageInfo pinfo = pmanager.getPackageInfo(context.getPackageName(), 0);
            //Log.d("itchen", "自身包名为：" + pinfo);
            //Log.d("itchen", "自身应用名字为：" + pinfo.applicationInfo.loadLabel(pmanager).toString());
            return pinfo == null ? "" : pinfo.applicationInfo.loadLabel(pmanager).toString();
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
        }

        /*try {
            PackageManager pm = Utils.getApp().getPackageManager();
            PackageInfo pi = pm.getPackageInfo(packageName, 0);
            return pi == null ? "" : pi.applicationInfo.loadLabel(pm).toString();
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
            return "";
        }*/

        return "";//暂时这样写没错

    }

    /**
     * 获取版本号内容，当前安装版本的版本号
     */
    public static int getVersionCode(Context context) {

        PackageManager manager = context.getPackageManager();

        int versionCode = 0;

        try {

            if (manager != null) {

                PackageInfo pInfo = manager.getPackageInfo(context.getPackageName(), 0);

                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
                    versionCode = (int) pInfo.getLongVersionCode(); // avoid huge version numbers and you will be ok
                } else {
                    //noinspection deprecation
                    versionCode = pInfo.versionCode;
                }

            }

        } catch (PackageManager.NameNotFoundException e) {

            e.printStackTrace();

        }

        return versionCode;
    }

    /**
     * 普通的webView的加载
     */
    public final static void setWebViewNomal(Context context, android.webkit.WebView webViewNomal) {

        webViewNomal.getSettings().setJavaScriptEnabled(true);////启用js

        webViewNomal.getSettings().setAllowFileAccess(true);//允许访问文件数据。

        //已过时的方法
        //webViewNomal.getSettings().setLayoutAlgorithm(android.webkit.WebSettings.LayoutAlgorithm.NARROW_COLUMNS);//可能的话使所有列的宽度不超过屏幕宽度

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
            webViewNomal.getSettings().setLayoutAlgorithm(android.webkit.WebSettings.LayoutAlgorithm.TEXT_AUTOSIZING);
        } else {
            webViewNomal.getSettings().setLayoutAlgorithm(android.webkit.WebSettings.LayoutAlgorithm.NORMAL);
        }

        webViewNomal.getSettings().setSupportZoom(false);//支持双击缩放，不支持触摸缩放
        webViewNomal.getSettings().setBuiltInZoomControls(false);
        webViewNomal.getSettings().setUseWideViewPort(true);//自适应屏幕
        webViewNomal.getSettings().setSupportMultipleWindows(false);//打开多个页面。原来是false
        //webViewNomal.getSettings().setAppCacheEnabled(true);//android13的废弃
        webViewNomal.getSettings().setDatabaseEnabled(true);//开启数据库存储模式
        webViewNomal.getSettings().setDomStorageEnabled(true);//开启Dom模式存储
        webViewNomal.getSettings().setJavaScriptEnabled(true);
        webViewNomal.getSettings().setGeolocationEnabled(true);
        //webViewNomal.getSettings().setAppCacheMaxSize(Long.MAX_VALUE);

        //第二次改造
        //webViewNomal.getSettings().setAppCachePath(PathUtils.getInternalAppCachePath());
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT) {
            //webView.getSettings().setDatabasePath("/data/data/" + webView.getContext().getPackageName() +"/databases/");
            webViewNomal.getSettings().setDatabasePath(PathUtils.getInternalAppCachePath());
        }

        webViewNomal.getSettings().setGeolocationDatabasePath(PathUtils.getInternalAppCachePath());

        //第一次改造
        //mWebView.getSettings().setAppCachePath(PathUtils.getInternalAppCachePath()+"/appcache");
        //mWebView.getSettings().setDatabasePath(PathUtils.getInternalAppCachePath()+"/databases");
        //mWebView.getSettings().setGeolocationDatabasePath(PathUtils.getInternalAppCachePath()+"/geolocation");

        //LogUtils.d("itchen---appcache商品详情缓存的路径->"+PathUtils.getInternalAppCachePath()+"/appcache");
        //LogUtils.d("itchen---databases商品详情缓存的路径->"+PathUtils.getInternalAppCachePath()+"/databases");
        // itchen---databases商品详情缓存的路径->/data/user/0/com.dgj.dinggovern/cache/databases
        // itchen---appcache商品详情缓存的路径->/data/user/0/com.dgj.dinggovern/cache/appcache

        webViewNomal.getSettings().setBlockNetworkImage(false);
        webViewNomal.getSettings().setPluginState(android.webkit.WebSettings.PluginState.ON_DEMAND);
        webViewNomal.getSettings().setRenderPriority(android.webkit.WebSettings.RenderPriority.HIGH);//提高渲染等级

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {//MIXED_CONTENT_ALWAYS_ALLOW
            //webViewX5.getSettings().setMixedContentMode(WebSettings.LOAD_NORMAL);
            webViewNomal.getSettings().setMixedContentMode(android.webkit.WebSettings.MIXED_CONTENT_ALWAYS_ALLOW);
        }

        if (Build.VERSION.SDK_INT >= 19) {
            webViewNomal.setLayerType(View.LAYER_TYPE_HARDWARE, null);
        }

        webViewNomal.getSettings().setCacheMode(android.webkit.WebSettings.LOAD_DEFAULT);


        //----------------------------------------------------------------
//        CookieSyncManager.createInstance(Utils.getApp());
//
//        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
//            CookieSyncManager.getInstance().sync();//同步cookie
//        } else {
//            CookieManager.getInstance().flush();
//        }
        //----------------------------------------------------------------
        //2023-2-3 13:40:59 修改过时的代码
        CookieManager cookieManager = CookieManager.getInstance();
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
            //CookieSyncManager.createInstance(context);
            CookieManager.getInstance().flush();
        }
        cookieManager.setAcceptCookie(true);

        //----------------------------------------------------------------

        webViewNomal.setOverScrollMode(View.OVER_SCROLL_ALWAYS);

    }

    /**
     * 只要是操作过后门，那么就立即切换到正常的情况
     */
    public static void judgeBackDoor(final Activity _activity, final Session _session) {//
        //默认是 没有操作过后门的
        //boolean isOperateDoor = MMKV.defaultMMKV().decodeBool(ConstantApi.ISOPERATEDOOR);
        LogUtils.d("itchen--->是否操作过后门-->" + MMKV.defaultMMKV().decodeBool(ConstantSign.ISOPERATEDOOR));

        //这里造成首页紊乱,如果发现用户做了
        if (MMKV.defaultMMKV().decodeBool(ConstantSign.ISOPERATEDOOR)) {//如果【是操作过后门】，那么纠正过来到当前所处的环境。

            Observable.just(0, 1)//
                    .subscribeOn(AndroidSchedulers.mainThread())//
                    .observeOn(AndroidSchedulers.mainThread())//
                    .subscribe(new Consumer<Integer>() {//
                        @Override
                        public void accept(Integer integer) throws Exception {

                            if (integer == 0) {

                                ClearAllOutData(_session, _activity, MMKV.defaultMMKV().decodeString(ConstantSign.P_INPUTNAMELASTTIME));

                            } else if (integer == 1) {

                                MMKV.defaultMMKV().encode(ConstantSign.ISOPERATEDOOR, false);//重置为未操作过后门的状态
                                //同时设置当前用户所在的环境，纠正为正常的 是【正式环境】还是【测试环境】
                                MMKV.defaultMMKV().encode(ConstantSign.ENVIRONMENT, ApiService.IS_RELEASE ? ApiService.VALUE_ENVIRONMENT_OFFICIAL : ApiService.VALUE_ENVIRONMENT_TEST);

                            }

                        }
                    });
        }
    }

    /**
     * @return void
     * @Title: switchBackDoor
     * @Description: 切换后门, 清空必要的数据和重新获取config接口
     */
    public final static void ClearAllOutData(Session _session, Activity _activity, String _curInputLoginName) {

        loginOutClearData(_session, _curInputLoginName);

        //01重新获取token
        //02测试环境下的配置文件。
        CommUtils.getSystemConfig(_activity, _session, new ApiRequestSubListener() {//为了上传日志信息

            @Override
            public void handlerSomeThingNotSuccessDataForItSelf(int what_method, String serverCode, String serverMessage) {
                super.handlerSomeThingNotSuccessDataForItSelf(what_method, serverCode, serverMessage);
            }
        });

    }

//    public final static void clearAllOutDataLargeVersion(Session _session, Activity _activity, String _curInputLoginName) {
//
//        loginOutClearDataLargeVersion(_session, _curInputLoginName);
//
//        //01重新获取token
//        //02测试环境下的配置文件。
////        CommUtils.getSystemConfig(_activity, _session, new ApiRequestSubListener() {//为了上传日志信息
////
////            @Override
////            public void handlerSomeThingNotSuccessDataForItSelf(int what_method, String serverCode, String serverMessage) {
////                super.handlerSomeThingNotSuccessDataForItSelf(what_method, serverCode, serverMessage);
////            }
////        });
//
//    }


    /**
     * 切换环境也走这个逻辑
     * 用户退出登录的处理逻辑。
     * 第二个参数的意思是可能会做对 旧的登录名的再次记录
     */
    public static void loginOutClearData(Session _session, String _curInputInputName) {

        //退出登录对于【当前所在环境-正式或者测试-不用管】因为有可能是换一个账号而已：例如测试环境2个账号来回切换
        //连同这条数据库 的登录数据库一起删除；
//        LoginInfoDaoManager.getInstance().deleteloginInfoById(_session.getCustomerId());

        //清空登录状态，记录为 未登录；
        MMKV.defaultMMKV().encode(ConstantSign.P_ISLOGIN, false);
        //清空token
        MMKV.defaultMMKV().encode(ConstantSign.P_TOKEN, false);

        //个人信息类的就不保留；
        _session.setPhotoUrl("");
        //清空昵称
        _session.setNickName("");
        //清空真实部门
        _session.setTrueName("");
        //清空手机号
        _session.setUserPhone("");

        //清空其他项
//        _session.setLogin(false);
        //LogUtils.d(ConstantSign.LOGCAT_NOMAL+"即将设置--登录状态为-false");

        //清空之后直接立即 将原来的用户名存储起来：因为在【切换环境】的时候,还保持旧输入的账号；
        MMKV.defaultMMKV().encode(ConstantSign.P_INPUTNAMELASTTIME, _curInputInputName);

        //清空这个用户的 未读消息的数量,设置为0即可；
        MMKV.defaultMMKV().encode(ConstantSign.MESSAGE_NOREAD_NUMBER, 0);

        //2024年1月13日10:32:15 清空友盟本地记录的信息
        MMKV.defaultMMKV().encode(ConstantSign.UMENG_PUSHAGENT_REGISTER_DEVICETOKEN, "");

        //清空首页记录的【员工管理的店铺信息】
        MMKV.defaultMMKV().encode(ConstantSign.P_SHOPINFONAME, "");
        //清空用户的展示名称 2024-2-27
        MMKV.defaultMMKV().encode(ConstantSign.P_TRUENAME, "");
        //清空用户手机号 2024-2-27
        MMKV.defaultMMKV().encode(ConstantSign.P_USERPHONE, "");
        //清空用户工作岗位 2024-2-27
        MMKV.defaultMMKV().encode(ConstantSign.P_WORKJOB, "");
        //--------------------------------------------------------------------------------------------
        //清空 【所有服务站】的所有存储信息；
//        StationDaoManager.getInstance().deleteAllStationInfoEntryInfoBean();
        //其他数据库是否要清空；

    }


    /**
     * 添加日志的 报错信息格式 分开code和message的格式。
     */
    public static String addLogFormatCodeMessage(String responseCode, String responseMessage) {
        //return ("code=" + hashMapResponse.succeed().getCode() + "&message=" + hashMapResponse.succeed().getMessage());
        //return ("code=" + responseCode + "&message=" + responseMessage + "&data=" + response.succeed().getData());
        return ("code=" + responseCode + "&message=" + responseMessage);
    }

    /**
     * @date 2018/4/10 0010
     * @auther itchenqi
     * @description 普通提示关闭弹窗, 带有【关闭】按钮,这里可能要自己做变量的销毁回收的
     */
    public static final AlertView method_showAlertView(Context context,//
                                                       String messageContent,//
                                                       OnItemClickListener onItemClickListener) {//

        return new AlertView(ConstantSign.ALERT_TITLE,//
                messageContent, //
                null,//
                new String[]{ConstantSign.ALERT_SINGLE}, //
                null, //
                context, //
                AlertView.Style.Alert,//
                onItemClickListener);
        //.setCancelable(true)//
        //.show();//

    }

    /**
     * 添加一个短的提示，2021年10月11日新增的一个简短的提示
     *
     * @param _context
     * @param _messageContent
     * @param _alertView
     */
    //private final int WHAT_UPLOAD_SINGLE = 0x01;
    public static void method_showAlert(Context _context, String _messageContent, AlertView _alertView) {

        CommUtils.checkDialog(_alertView);

//        _alertView = new AlertView("提示",//
        _alertView = new AlertView(ConstantSign.ALERT_TITLE,//
                _messageContent, //
                null,//
                new String[]{ConstantSign.ALERT_SINGLE}, //
                null, //
                _context, //
                AlertView.Style.Alert,//
                null);

        _alertView.setCancelable(true)//默认是false
                .show();//

    }

    /**
     * 一个弹窗吐司类型,没有【关闭按钮】
     */
    public static AlertView method_showAlertViewToast(Context _context, String _title, String _message, boolean _isCanvelable) {

        return new AlertView(_title,//
                _message, //
                null,//
                null, //new String[]{ConstantApi.ALERT_SINGLE}
                null, //
                _context, //
                AlertView.Style.Alert,//
                null)//
                .setCancelable(_isCanvelable);

    }

    /**
     * 普通的关闭提示弹窗内容
     */
    public static void method_showAlertViewSingle(Context _context, //
                                                  String _title, //
                                                  String _message,//
                                                  boolean _isCanvelable) {//

        new AlertView(_title,//
                _message, //
                null,//
                new String[]{ConstantSign.ALERT_SINGLE}, //
                null, //
                _context, //
                AlertView.Style.Alert,//
                null)//
                .setCancelable(_isCanvelable)//
                .show();//


    }

    /**
     * 携带两个点击按钮的弹窗提示内容,没有标题
     */
    public static AlertView method_showAlertViewTwoButton(Context _context, //
                                                          String leftButton, //
                                                          String rightButton,//
                                                          String _message,//
                                                          boolean _isCanvelable,//
                                                          OnItemClickListener onItemClickListener) {//
        //打开网络设置
        return new AlertView(ConstantSign.ALERT_TITLE, //添加标题的两个按钮
                _message, //
                leftButton, //
                new String[]{rightButton}, //
                null, //
                _context,//
                AlertView.Style.Alert, //
                onItemClickListener);

        //.setCancelable(_isCanvelable)//
        //.show();//


    }

    /**
     * 普通的关闭提示弹窗内容:创建比较精准的 但是较慢的 弹窗提示，一般用这种，【这种包含标题】
     */
    public static AlertView method_showAlertViewSingleSlowly(Context _context,//
                                                             String _title,//
                                                             String _message, //
                                                             boolean _isCanvelable) {//

        return new AlertView(_title,//
                _message, //
                null,//
                new String[]{ConstantSign.ALERT_SINGLE}, //
                null, //
                _context, //
                AlertView.Style.Alert,//
                null)//
                .setCancelable(_isCanvelable);//

    }

    //使用 BasePopupView 做弹窗,是单个的弹窗
    public static BasePopupView method_showBasePopupViewSingle(Activity _activity, Context _context, String _mesage) {

        //获取屏幕宽度i
        int screenWith = ScreenUtils.getScreenWidth();
        int currentWith = (int) (screenWith * 0.8f);
//                    LinearLayout.LayoutParams layoutParams = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.MATCH_PARENT);
//                    FrameLayout.LayoutParams layoutParams = new FrameLayout.LayoutParams(currentWith, LinearLayout.LayoutParams.WRAP_CONTENT);
//                    layoutParams.gravity= Gravity.CENTER;
//                    View viewPopu = popupView.getPopupContentView();
//                    viewPopu.setLayoutParams(layoutParams);

        XPopup.Builder builder = new XPopup.Builder(_context);

        ConfirmPopupView confirmPopupView = builder.asConfirm(ConstantSign.ALERT_TITLE, _mesage,
                "",//
                _activity.getResources().getString(R.string.submitchangeclose),//
                new OnConfirmListener() {
                    @Override
                    public void onConfirm() {

                        //

                    }
                }, null, true);

        builder.isDestroyOnDismiss(true);
        builder.popupWidth(currentWith);

//                  confirmPopupView.getTitleTextView().setTextColor(getResources().getColor(R.color.headmanblue));
        TextView titleTextView = confirmPopupView.getTitleTextView();
        titleTextView.setTextSize(15f);
        titleTextView.setTypeface(null, Typeface.BOLD);

        //这里要弹窗？那这个方法做什么？popupView.show();
        BasePopupView basePopupView = confirmPopupView.show();

//                    TextView textViewConfirm = confirmPopupView.getConfirmTextView();
//                    textViewConfirm.setTextColor(ColorUtils.getColor(R.color.headmanblue));

//                    confirmPopupView.getConfirmTextView().setText(getResources().getString(R.string.submitchangeclose));
        //getResources().getColor(R.color.headmanblue)

//                    XPopup.Builder  builder = XPopup.Builder(getContext()).;
//                    BasePopupView popupView = confirmPopupView.show();
//                    popupView.show()
//                    popupView.getPopupContentView().get

        return basePopupView;

    }

    /**
     * 自己设计的关于列表设置文字内容的方法
     */
    public static final void setText(TextView textView, String text) {

        if (textView != null) {
            if (!TextUtils.isEmpty(text)) {
                if (TextUtils.equals(text, "null") || TextUtils.equals(text, "NULL")) {
                    textView.setText("");
                } else {
                    //2020年我自己去掉的首尾空格，不知道会不会有大的影响。
                    textView.setText(text.trim());
                }
            } else {
                textView.setText("");
            }
        } else {
//            LogUtils.d(ConstantSign.LOGCAT_NOMAL + "setText--的文本是空值null");
        }

    }

    public static void setNetwork(Activity _activity) {

        //打开网络设置
        new AlertView(ConstantSign.ALERT_TITLE, //
                ConstantSign.NET_WORKSETTING, //
                "取消", //
                new String[]{"打开"}, //
                null, //
                _activity,//
                AlertView.Style.Alert, //
                new OnItemClickListener() {//
                    @Override
                    public void onItemClick(Object o, int position) {//
                        if (position != AlertView.CANCELPOSITION) {
                            NetworkUtils.openWirelessSettings();//
                        }
                    }//
                }).setCancelable(true)//
                .show();//

    }

    /**
     * 填充webview的缓存的方式0是不使用缓存，1是使用缓存，2是使用其他的缓存方式
     */
    public final static void setWebViewX5(com.tencent.smtt.sdk.WebView webViewX5, int isUseCacheLoadFlag) {

        //webViewX5.setVerticalScrollBarEnabled(false);//取消Vertical ScrollBar显示
        //webViewX5.setHorizontalScrollBarEnabled(false); //取消Horizontal ScrollBar显示

        webViewX5.getSettings().setJavaScriptEnabled(true);////启用js
//        webViewX5.setima(true);    //支持自动加载图片

        webViewX5.getSettings().setAllowFileAccess(true);//允许访问文件数据。
        webViewX5.getSettings().setLayoutAlgorithm(WebSettings.LayoutAlgorithm.NARROW_COLUMNS);//可能的话使所有列的宽度不超过屏幕宽度
        webViewX5.getSettings().setSupportZoom(false);//支持双击缩放，不支持触摸缩放
        webViewX5.getSettings().setBuiltInZoomControls(false);
        webViewX5.getSettings().setUseWideViewPort(true);//自适应屏幕
        webViewX5.getSettings().setSupportMultipleWindows(false);//打开多个页面。原来是false
        webViewX5.getSettings().setAppCacheEnabled(true);//
        webViewX5.getSettings().setDatabaseEnabled(true);//开启数据库存储模式
        webViewX5.getSettings().setDomStorageEnabled(true);//开启Dom模式存储
        webViewX5.getSettings().setJavaScriptEnabled(true);
        webViewX5.getSettings().setGeolocationEnabled(true);
        webViewX5.getSettings().setAppCacheMaxSize(Long.MAX_VALUE);

        //第二次改造
        webViewX5.getSettings().setAppCachePath(PathUtils.getInternalAppCachePath());
        webViewX5.getSettings().setDatabasePath(PathUtils.getInternalAppCachePath());
        webViewX5.getSettings().setGeolocationDatabasePath(PathUtils.getInternalAppCachePath());

        //第一次改造
        //mWebView.getSettings().setAppCachePath(PathUtils.getInternalAppCachePath()+"/appcache");
        //mWebView.getSettings().setDatabasePath(PathUtils.getInternalAppCachePath()+"/databases");
        //mWebView.getSettings().setGeolocationDatabasePath(PathUtils.getInternalAppCachePath()+"/geolocation");

        //LogUtils.d("itchen---appcache商品详情缓存的路径->"+PathUtils.getInternalAppCachePath()+"/appcache");
        //LogUtils.d("itchen---databases商品详情缓存的路径->"+PathUtils.getInternalAppCachePath()+"/databases");
        // itchen---databases商品详情缓存的路径->/data/user/0/com.dgj.dinggovern/cache/databases
        // itchen---appcache商品详情缓存的路径->/data/user/0/com.dgj.dinggovern/cache/appcache

        webViewX5.getSettings().setBlockNetworkImage(false);
        webViewX5.getSettings().setPluginState(WebSettings.PluginState.ON_DEMAND);
        webViewX5.getSettings().setRenderPriority(WebSettings.RenderPriority.HIGH);//提高渲染等级

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {//MIXED_CONTENT_ALWAYS_ALLOW
            //webViewX5.getSettings().setMixedContentMode(WebSettings.LOAD_NORMAL);
            webViewX5.getSettings().setMixedContentMode(android.webkit.WebSettings.MIXED_CONTENT_ALWAYS_ALLOW);
        }

        //2019年09月20日抓到崩溃
        //从KitKat开始，遇到了WebViews的问题（冻结，崩溃）
        //已经解决了这些问题，停用了webViews的硬件加速 好像在5.1会出现
        //if (Build.VERSION.SDK_INT>=Build.VERSION_CODES.HONEYCOMB)//有的人写到11版本
        if (Build.VERSION.SDK_INT >= 19) {//KITKAT
            webViewX5.setLayerType(View.LAYER_TYPE_HARDWARE, null);
        }

        if (isUseCacheLoadFlag == 0) {
            webViewX5.getSettings().setCacheMode(WebSettings.LOAD_NO_CACHE);
        } else if (isUseCacheLoadFlag == 1) {
            webViewX5.getSettings().setCacheMode(WebSettings.LOAD_DEFAULT);
        }

        com.tencent.smtt.sdk.CookieSyncManager.createInstance(Utils.getApp());

        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
            com.tencent.smtt.sdk.CookieSyncManager.getInstance().sync();//同步cookie
        } else {
            com.tencent.smtt.sdk.CookieManager.getInstance().flush();
        }
        webViewX5.setOverScrollMode(View.OVER_SCROLL_ALWAYS);
    }

    public static MaterialDialog createMaterialDialog(Activity _activity, String contentValue) {

        //CommUtils.checkMaterialDialog(registrationDialog);
        MaterialDialog.Builder builder = new MaterialDialog.Builder(_activity)//
                .content(contentValue + "...")//自定义的
//                .contentColor(ContextCompat.getColor(Utils.getApp(), R.color.graycontent))//为了低版本兼容
                .contentColor(ContextCompat.getColor(_activity, R.color.graycontent))//为了低版本兼容
                .progress(true, 0)//
                .progressIndeterminateStyle(false)//
                .cancelable(true);
//                .show();

//        MaterialDialog materialDialogCurrent = null;
//        if (((Activity) _activity).hasWindowFocus()) {
//            materialDialogCurrent = builder.show();
//        }

        return builder.show();
    }

    /**
     * 用户信息失效提示
     */
    public static void loginInfoOutLogic(Activity activity, String message, String _curInputLoginName) {
        loginOutClearData(Session.get(activity), _curInputLoginName);//用户信息失效，清空用户信息。
        loginOutAlertView(activity, message);
    }

    //和H5对接的弹窗被顶下线的
    public static void loginInfoOutLogicH5(Activity activity, String message, String _curInputLoginName) {
        loginOutClearData(Session.get(activity), _curInputLoginName);//用户信息失效，清空用户信息。
        loginOutAlertViewH5(activity, message);
    }

    /**
     * 手动弹出重新登录弹窗,这里会发现出现
     */
    public static void loginOutAlertView(Activity activity, String message) {

        //LogUtils.d(ConstantSign.LOGCAT_NOMAL + "loginOutAlertView--所在的线程");
        //JavaBridge, com.ygxsk.integrated.utils.CommUtils.loginOutAlertView(CommUtils.java:1177)

        methodShowLoginOutDialog(activity, message);

        /*Bundle bundle = new Bundle();
        bundle.putInt(ConstantApi.EXTRA_REQUEST_20401,ConstantApi.REQUEST_20401);
        ActivityUtils.startActivity(bundle,LoginActivity.class);*/
        //这种情况下 应该是所有的界面都被杀死了，只有LoginActivity还在，并且点击login的物理按键两次是退出的。
        //ActivityUtils.finishActivity();

    }

    public static void loginOutAlertViewH5(Activity activity, String message) {

//        LogUtils.d(ConstantSign.LOGCAT_NOMAL + "loginOutAlertView--所在的线程");
        //JavaBridge, com.ygxsk.integrated.utils.CommUtils.loginOutAlertView(CommUtils.java:1177)

        activity.runOnUiThread(new Runnable() {
            @Override
            public void run() {

                methodShowLoginOutDialog(activity, message);

            }
        });

        /*Bundle bundle = new Bundle();
        bundle.putInt(ConstantApi.EXTRA_REQUEST_20401,ConstantApi.REQUEST_20401);
        ActivityUtils.startActivity(bundle,LoginActivity.class);*/
        //这种情况下 应该是所有的界面都被杀死了，只有LoginActivity还在，并且点击login的物理按键两次是退出的。
        //ActivityUtils.finishActivity();

    }

    public static void methodShowLoginOutDialog(Activity activity, String message) {

        //2018年06月09日发现这里会出现2个或者3个重新登录弹窗
        CommUtils.checkDialog(mAlertViewLogin);

        mAlertViewLogin = new AlertView.Builder()//
                .setContext(activity)////
                .setStyle(AlertView.Style.Alert)//
                .setTitle(ConstantSign.ALERT_TITLE)//没有标题内容
                .setMessage(message).setCancelText("退出应用")//
                .setDestructive("重新登录")//
                .setOnItemClickListener(new OnItemClickListener() {

                    @Override
                    public void onItemClick(Object o, int position) {
                        //这应该是确定的点击事件内容
                        //ToastUtils.showToast(HomeFragment.this.getActivity(),"测试拨打弹窗");
                        if (position == AlertView.CANCELPOSITION) {//退出应用,左侧按钮

                            if (MianTaskManager.getInstance(Utils.getApp()) != null) {
                                MianTaskManager.getInstance(Utils.getApp()).finishAllActivity();
                            }

                            //其实应该是让该Activity杀死掉的
                            if (ActivityUtils.isActivityAlive(activity)) {
                                ActivityUtils.finishActivity(activity);
                            }

                            //这个就是做个加强。
                            ActivityUtils.finishAllActivities();

                            AppUtils.exitApp();

                        } else {//重新登陆

                            //如果该页面【是登录页】，就不杀死，如果【不是登录页】就杀死，其实应该是让该Activity杀死掉的
                            if (activity instanceof LoginCarActivity) {

                                //是【登录页】就不杀死，直接在改页面执行；
//                                LogUtils.d(ConstantSign.LOGCAT_NOMAL, "当前页面是 登录 页面");

                            } else {

//                                LogUtils.d(ConstantSign.LOGCAT_NOMAL, "当前页面  不是 登录 页面");

                                Bundle bundle = new Bundle();
                                bundle.putInt(ExtraKey.EXTRA_REQUEST_20401, ExtraValue.RESPONSE_20401);
                                ActivityUtils.startActivity(bundle, LoginCarActivity.class);

                                if (ActivityUtils.isActivityAlive(activity)) {
                                    ActivityUtils.finishActivity(activity);
                                }

                            }

                            //上一个界面应该是让他死掉的。
                            CommUtils.checkDialog(mAlertViewLogin);
                        }
                    }
                }).setOthers(null)//
                .build();//

        //杀死之前的
        //判断Activity是否活着，活着就弹窗
        if (ActivityUtils.isActivityAlive(activity)) {
            mAlertViewLogin.setCancelable(false).show();
        }

    }


    /**
     * @date 2018/3/3 0003
     * @auther itchenqi
     * @description 处理activity报错界面处理信息
     */
    public static void checkCurrently(ErrorActivity errorActivity, String serverCode, int imageActionflag, String errorMessage, String errorBackupMessage) {

        if (!TextUtils.isEmpty(errorMessage)) {

            if (errorActivity != null) {

                //2023年5月4日10:18:12：serverCode 将来做打印日志的拦截 如果是throw各种用户看不懂的报错改为用户看得懂的翻译；
//                if (TextUtils.equals(serverCode,ConstantSign.REQUEST_30003)){
//                    errorMessage = ConstantSign.REQUEST_30003_TEXT;
//                }

                errorActivity.fillNullDataView(errorMessage, imageActionflag);
            }

        } else {
            if (errorActivity != null) {
                errorActivity.fillNullDataView(errorBackupMessage, imageActionflag);
            }

        }

    }

    /**
     * @date 2018/3/3 0003
     * @auther itchenqi
     * @description 处理Fragment内容的报错图片信息
     */
    public static void checkCurrently(BaseImmersionFragment fragmentSub, String serverCode, int imageActionflag, String errorMessage, String errorBackupMessage) {

        if (!TextUtils.isEmpty(errorMessage)) {
            if (fragmentSub != null) {

                if (fragmentSub.isAdded()) {

                    //                if (TextUtils.equals(serverCode,ConstantSign.REQUEST_30003)){
//                    errorMessage = ConstantSign.REQUEST_30003_TEXT;
//                }

                    fragmentSub.fillNullDataView(errorMessage, imageActionflag);
                    //LogUtils.d("itchen-----checkCurrently添加上了!");
                }
            }

        } else {
            if (fragmentSub != null) {
                if (fragmentSub.isAdded()) {
                    fragmentSub.fillNullDataView(errorBackupMessage, imageActionflag);
                }
            }

        }

    }


    //==========================================================================================
    /*//方法一
    BigDecimal bg1 = new BigDecimal("1.1");
    //方法二
    BigDecimal bg2 = new BigDecimal(Double.toString(1.1));
    //方法三
    BigDecimal bg3 = BigDecimal.valueOf(1.1);
    System.out.println(bg1.toString());
    System.out.println(bg2.toString());
    System.out.println(bg3.toString());
    运行结果:
            1.1
            1.1
            1.1*/

    //移除小数点后边的数字
    public static BigDecimal formatRemoveDotAfter(BigDecimal _bigDecimal) {
        //这三种写法都可以；
        //BigDecimal c2 = BigDecimal.valueOf(9.9).setScale(0, BigDecimal.ROUND_DOWN);
        //BigDecimal c3 = BigDecimal.valueOf(9.1).setScale(0, BigDecimal.ROUND_FLOOR);
        //BigDecimal c4 = BigDecimal.valueOf(9.9).setScale(0, BigDecimal.ROUND_FLOOR);

        //BigDecimal result = BigDecimal.valueOf(_bigDecimal).setScale(0, BigDecimal.ROUND_FLOOR);
        if (_bigDecimal != null) {
            BigDecimal result = _bigDecimal.setScale(0, BigDecimal.ROUND_FLOOR);
            return result;
        }

        return CommUtils.formatComma2BigDecimal(0);

    }

    /**
     * 新创建BigDecimal
     */
    public static BigDecimal valueOf(double val) {
        return new BigDecimal(Double.toString(val));
    }

    //做小数点格式化处理
    public static BigDecimal formatComma2BigDecimal(Object obj) {

        String val = String.valueOf(obj);

        if (val == null)
            return new BigDecimal("0.00");

        val = val.replaceAll(",", "");

        //if (!isNumber(val))
        // return new BigDecimal("0.00");

        BigDecimal decimal = new BigDecimal(val);//不要四舍五入
        //decimal = decimal.setScale(2, RoundingMode.HALF_UP);
        //decimal = decimal.setScale(2, BigDecimal.ROUND_UNNECESSARY);
        decimal = decimal.setScale(2, BigDecimal.ROUND_DOWN);

        return decimal;

    }

    /**
     * 仅仅只有H5的弹窗需要这个 因为貌似线程执行 不是主线程
     */
    public static void authorityRequestJsH5(Activity mActivityInstance, String content, AuthorityCallbackListener authorityCallbackListener) {

//        //弹窗说明调用权限的理由
//        MaterialDialog materialDialog = new MaterialDialog.Builder(mActivityInstance)//
//                .title(ConstantApi.MATERIALDIALOG_AUTHORITY_TITLE)//
//                //.titleGravity(GravityEnum.CENTER)//
//                //.content(ConstantApi.MATERIALDIALOG_AUTHORITY_CONTENT)//
//                .content(content)//
//                .theme(Theme.LIGHT)//这里只能是白色的主体
//                .positiveText(ConstantApi.MATERIALDIALOG_AUTHORITY_CAMERA)//
//                .positiveColor(ColorUtils.getColor(R.color.red_pressed))//
//                .onPositive(new MaterialDialog.SingleButtonCallback() {
//                    @Override
//                    public void onClick(@NonNull MaterialDialog dialog, @NonNull DialogAction which) {
//
//                        if (authorityCallbackListener != null) {
//                            authorityCallbackListener.doSomeThing();
//                        }
//
//                    }
//                }).cancelable(true)//
//                .show();//
//
//        if (materialDialog != null) {
//            materialDialog.getTitleView().setTextSize(17);
//        }

        //2022年12月31日10:28:07 发现华为手机上只要调整了【字号】就会出现弹窗无法弹出的问题；
        //-----------------------------------------------------------------------------------------
        mActivityInstance.runOnUiThread(new Runnable() {
            @Override
            public void run() {

                new AlertView(ConstantSign.MATERIALDIALOG_AUTHORITY_TITLE,//
                        content, //
                        null,//
                        new String[]{ConstantSign.MATERIALDIALOG_AUTHORITY_CAMERA}, //
                        null, //
                        mActivityInstance, //
                        AlertView.Style.Alert,//
                        new OnItemClickListener() {
                            @Override
                            public void onItemClick(Object o, int position) {

                                if (position != AlertView.CANCELPOSITION) {

                                    if (authorityCallbackListener != null) {
                                        authorityCallbackListener.doSomeThing();
                                    }

                                }

                            }
                        })//
                        .setCancelable(true).show();//
            }
        });
        //-----------------------------------------------------------------------------------------


    }

    /**
     * 打开权限的声明弹窗,设置自定义的弹窗。
     * 2024年1月27日11:45:26
     */
    public static MaterialDialog authorityRequest(Activity mActivityInstance, String content, AuthorityCallbackListener authorityCallbackListener) {

        //第一种权限打开的方式
//        //弹窗说明调用权限的理由
//        MaterialDialog materialDialog = new MaterialDialog.Builder(mActivityInstance)//
//                .title(ConstantApi.MATERIALDIALOG_AUTHORITY_TITLE)//
//                //.titleGravity(GravityEnum.CENTER)//
//                //.content(ConstantApi.MATERIALDIALOG_AUTHORITY_CONTENT)//
//                .content(content)//
//                .theme(Theme.LIGHT)//这里只能是白色的主体
//                .positiveText(ConstantApi.MATERIALDIALOG_AUTHORITY_CAMERA)//
//                .positiveColor(ColorUtils.getColor(R.color.red_pressed))//
//                .onPositive(new MaterialDialog.SingleButtonCallback() {
//                    @Override
//                    public void onClick(@NonNull MaterialDialog dialog, @NonNull DialogAction which) {
//
//                        if (authorityCallbackListener != null) {
//                            authorityCallbackListener.doSomeThing();
//                        }
//
//                    }
//                }).cancelable(true)//
//                .show();//
//
//        if (materialDialog != null) {
//            materialDialog.getTitleView().setTextSize(17);
//        }

        //2022年12月31日10:28:07 发现华为手机上只要调整了【字号】就会出现弹窗无法弹出的问题；
        //第二种权限打开的方式
        //-----------------------------------------------------------------------------------------
//        new AlertView(ConstantSign.MATERIALDIALOG_AUTHORITY_TITLE,//
//                content, //
//                null,//
//                new String[]{ConstantSign.MATERIALDIALOG_AUTHORITY_CAMERA}, //
//                null, //
//                mActivityInstance, //
//                AlertView.Style.Alert,//
//                new OnItemClickListener() {
//                    @Override
//                    public void onItemClick(Object o, int position) {
//
//                        if (position != AlertView.CANCELPOSITION) {
//                            if (authorityCallbackListener != null) {
//                                authorityCallbackListener.doSomeThing();
//                            }
//                        }

//                    }
//                })//
//                .setCancelable(true).show();//
        //---------------------------------------------------------------------------------------------

        //第三种权限声明方式：2024年1月27日11:21:59
        View viewCard = View.inflate(mActivityInstance, R.layout.alertview_permissions, null);

        //填充的文本信息
        TextView textViewCardDesInfo = (TextView) viewCard.findViewById(R.id.textviewcarddesinfodesinfo);
        //设置权限按钮
        RoundTextView textViewAlertViewPermission = (RoundTextView) viewCard.findViewById(R.id.textviewalertviewpermission);
        textViewCardDesInfo.setText(content);

        textViewAlertViewPermission.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {

                if (authorityCallbackListener != null) {
                    authorityCallbackListener.doSomeThing();
                }

            }
        });

        //因为有一个报错：bad winow token you canot show a dialog before an activiyt is create ed

        MaterialDialog.Builder builder = new MaterialDialog.Builder(mActivityInstance)
                .customView(viewCard, false)
//                .contentColor(ColorUtils.getColor(R.color.buttonnomcolor))//设置无效
//                .positiveColor(ColorUtils.getColor(R.color.dark))//设置无效
                .cancelable(true)
                .canceledOnTouchOutside(true);
        //.show();

        MaterialDialog materialDialogCurrent = null;

//        if (((Activity) mActivityInstance).hasWindowFocus()) {
//            materialDialogCurrent = builder.show();
//        }else{
//
//            materialDialogCurrent = builder.show();
//
//            LogUtils.d(ConstantSign.LOGCAT_NOMAL+"materialDialogCurrent 没有获取到焦点");
//        }

        materialDialogCurrent = builder.show();

        return materialDialogCurrent;

    }

    /**
     * 截图最后的名称的方法
     */
    public static String valueStringSplit(String _filePathUri) {

        if (!TextUtils.isEmpty(_filePathUri)) {

            return _filePathUri.substring(//
                    _filePathUri.lastIndexOf("/") + 1);
        } else {

            return "";
        }

    }

    //分割现有的时间；
    public static void valuePopuTime(String popuTime) {

        //特殊：这里因为如果是从详情进来的话，是要记录这个时间，做录入标记的
        if (!TextUtils.isEmpty(popuTime)) {

            // "createTime": "2023-05-11",
            String[] time = CommUtils.valueStringSplitTime(popuTime);

            String time1 = time[0];
            String time2 = time[1];
            String time3 = time[2];

            MMKV.defaultMMKV().encode(ConstantSign.MMKV_KEY_YEAR, Integer.parseInt(time1));
            MMKV.defaultMMKV().encode(ConstantSign.MMKV_KEY_MONTH, Integer.parseInt(time2));
            MMKV.defaultMMKV().encode(ConstantSign.MMKV_KEY_DAY, Integer.parseInt(time3));

//            LogUtils.d(ConstantSign.LOGCAT_NOMAL + MMKV.defaultMMKV().decodeInt(ConstantSign.MMKV_KEY_YEAR));
//            LogUtils.d(ConstantSign.LOGCAT_NOMAL + MMKV.defaultMMKV().decodeInt(ConstantSign.MMKV_KEY_MONTH));
//            LogUtils.d(ConstantSign.LOGCAT_NOMAL + MMKV.defaultMMKV().decodeInt(ConstantSign.MMKV_KEY_DAY));

        } else {
            //那么就清空这个时间，什么都不填充
            MMKV.defaultMMKV().removeValueForKey(ConstantSign.MMKV_KEY_YEAR);
            MMKV.defaultMMKV().removeValueForKey(ConstantSign.MMKV_KEY_MONTH);
            MMKV.defaultMMKV().removeValueForKey(ConstantSign.MMKV_KEY_DAY);
        }

    }

    public static String[] valueStringSplitTime(String inputTime) {
        //_workBookFirstNode.getCreateTime().split("-")
        if (!TextUtils.isEmpty(inputTime)) {
            String[] time3 = inputTime.split("-");
            return time3;
        }
        return null;
    }



    /*private String formatCommaAnd2Point(Object obj) {
        BigDecimal decimal = formatComma2BigDecimal(obj);

        DecimalFormat df = new DecimalFormat("#,###.00");
        String decimalStr = df.format(decimal).equals(".00") ? "0.00" : df.format(decimal);
        if (decimalStr.startsWith(".")) {
            decimalStr = "0" + decimalStr;
        }
        return decimalStr;
    }*/

    /*public static boolean isDouble(String value) {
        try {
            Double.parseDouble(value);
            if (value.contains("."))
                return true;
            return false;
        } catch (NumberFormatException e) {
            return false;
        }
    }*/

    /*public static boolean isInteger(String value) {
        try {
            Integer.parseInt(value);
            return true;
        } catch (NumberFormatException e) {
            return false;
        }
    }*/

    /*public static boolean isNumber(String value) {
        return isInteger(value) || isDouble(value);
    }*/

    //=================================================================================
    //支撑高度的 一个布局，因为书写评价的时候，软键盘挡住文本框
//    TextView textViewHelpSupportHeight = (TextView) findViewById(R.id.textviewhelpsupportheight);
//    //==============================================================================================
//    final ViewGroup.LayoutParams layoutParams = textViewHelpSupportHeight.getLayoutParams();
//    layoutParams.width = ViewGroup.LayoutParams.MATCH_PARENT;
//    layoutParams.height = ScreenUtils.getScreenHeight() / 2;
//        textViewHelpSupportHeight.setLayoutParams(layoutParams);
    //==============================================================================================

    /**
     * 设置底部软键盘的滚动，因为布局不够高
     *
     * @param textViewHelp
     */
    public static void methodHelpView(TextView textViewHelp) {

        final ViewGroup.LayoutParams layoutParams = textViewHelp.getLayoutParams();
        layoutParams.width = ViewGroup.LayoutParams.MATCH_PARENT;
        layoutParams.height = ScreenUtils.getScreenHeight() / 3;
        textViewHelp.setLayoutParams(layoutParams);

    }

    /**
     * 设置底部软键盘的滚动，因为布局不够高
     *
     * @param textViewHelp
     */
    public static void methodHelpView4(TextView textViewHelp) {

        final ViewGroup.LayoutParams layoutParams = textViewHelp.getLayoutParams();
        layoutParams.width = ViewGroup.LayoutParams.MATCH_PARENT;
        layoutParams.height = ScreenUtils.getScreenHeight() / 4;
        textViewHelp.setLayoutParams(layoutParams);

    }

    //设置五分之一屏幕的高度逻辑
    public static void methodHelpView5(TextView textViewHelp) {

        final ViewGroup.LayoutParams layoutParams = textViewHelp.getLayoutParams();
        layoutParams.width = ViewGroup.LayoutParams.MATCH_PARENT;
        layoutParams.height = ScreenUtils.getScreenHeight() / 5;
        textViewHelp.setLayoutParams(layoutParams);

    }

//    //处理个人信息接口；
//    public static void method_userInfo_handler(ProfileInfoBean profileInfoBean, Session _session) {
//
//        //----------------------------------------------------------
//        //外侧有用户信息，内侧也有,外侧是【userName】例如：01096,深耕社区；
//        String userLoginName = profileInfoBean.getUserName();
//        String userId = profileInfoBean.getUserId();
//        //在本地内存存一份；
//        _session.setLoginInfoUserId(userId);
//        _session.setLoginInfoUserName(userLoginName);
//
//        //----------------------------------------------------------
//        //设置是运营身份 还是服务站经理的身份
//        boolean isOperator = profileInfoBean.isOperator();
//        boolean isSiter = profileInfoBean.isSiter();
//        //设置到本地,为了获取【客户信息】+【到期客户】的编辑内容；
//        _session.setOperator(isOperator);
//        _session.setSiter(isSiter);
//        //----------------------------------------------------------
//        //这里将来使用分号隔开；
//        ArrayList<String> businessDeptNameList = profileInfoBean.getBusinessDeptName();
//
//        if (businessDeptNameList != null) {
//            LogUtils.d(ConstantSign.LOGCAT_NOMAL + "businessDeptNameList-->" + businessDeptNameList);
//        }
//
//        StringBuffer stringBufferTemp = new StringBuffer();
//
//        if (businessDeptNameList != null && !businessDeptNameList.isEmpty()) {
//
//            for (int indexPosition = 0; indexPosition < businessDeptNameList.size(); indexPosition++) {
//
//                String item = businessDeptNameList.get(indexPosition);
//                stringBufferTemp.append(item);
//
//                if (indexPosition != businessDeptNameList.size() - 1) {
//                    stringBufferTemp.append("；");
//                }
//
//            }
//
//        }
//
//        _session.setUserCreateBy(stringBufferTemp.toString());//部门，在【我的】顶部展示的
//
//        //个人信息实体
//        ProfileUserInfo profileUserInfo = profileInfoBean.getUser();
//
//        //用户姓名
//        if (profileUserInfo != null) {
//
//            //设置几个固定的
//            //mSession.set
//            _session.setPhotoUrl(profileUserInfo.getAvatar());
//            _session.setTrueName(profileUserInfo.getTrueName());
//            _session.setUserPhone(profileUserInfo.getPhonenumber());
//
//            MMKV.defaultMMKV().encode(ConstantSign.P_TRUENAME, profileUserInfo.getTrueName());
//            //这个该再执行一次刷新头部；
//            //LogUtils.d(ConstantSign.LOGCAT_NOMAL + "trueName =>" + MMKV.defaultMMKV().decodeString(ConstantSign.P_TRUENAME));
//
//            //如果这个信息获取完毕，刷新【我的】做刷新;刷新-头部；
//            //如果是退出登录，重新登录又获取的个人信息；这种必须刷新
//            HomeMainBroadcast homeMainBroadcast = new HomeMainBroadcast();
//            homeMainBroadcast.setMessage(ConstantApi.HOMEMAIN_BROADCAST_MINE_SINGLE);
//            EventBus.getDefault().post(homeMainBroadcast);
//
//            LoginInfo loginInfo = new LoginInfo();
//            loginInfo.setCreateBy(profileUserInfo.getCreateBy());//部门信息
//            loginInfo.setIdCard(profileUserInfo.getIdCard());//身份证信息
//            loginInfo.setNickName(profileUserInfo.getNickName());//昵称
//            loginInfo.setTrueName(profileUserInfo.getTrueName());//真实名称
//            loginInfo.setCustomerId(Long.parseLong(profileUserInfo.getUserId()));//
//            loginInfo.setPhotoUrl(profileUserInfo.getAvatar());//头像的链接内容，
//            loginInfo.setEmail(profileUserInfo.getEmail());//用户的邮箱信息，
//
//            LoginInfoDaoManager.getInstance().updateLoginInfoBean(loginInfo);
//
//        }
//
//    }

    /**
     * @param _phoneNumber
     * @return 这个是直接给电话号码复制过去 让用户自己决定要不要打
     */
    public static Intent callThePhoneNumAction_dial(String _phoneNumber) {

        //过滤掉特殊字符例如括号或者横杠
        Intent intent = new Intent();
        //String _phoneNumber1 = "转转转转转转转转";//"4002014311";
        //intent.setAction("android.intent.action.CALL");
        //Intent.ACTION_DIAL
        //intent.setAction("android.intent.action.DIAL");
        intent.setAction(Intent.ACTION_DIAL);
        intent.setData(Uri.parse("tel:" + filter(_phoneNumber)));

        //添加拨打电话的意图

        return intent;
    }

    /**
     * @date 2018/5/18 0018
     * @auther itchenqi
     * @description 替换掉特殊字符内容
     */
    public static String filter(String str) {
        String regEx = "[`~!@#$%^&*()\\-+={}':;,\\[\\].<>/?￥%…（）_+|【】‘；：”“’。，、？\\s]";
        Pattern p = Pattern.compile(regEx);
        Matcher m = p.matcher(str);
        return m.replaceAll("").trim();
    }

    /**
     * 复制文本到剪切板
     */
    public static void methodCopyClip(String result, boolean isShowToast) {

        // 从API11开始android推荐使用android.content.ClipboardManager
        // 为了兼容低版本我们这里使用旧版的android.text.ClipboardManager，虽然提示deprecated，但不影响使用。
        ClipboardManager cm = (ClipboardManager) Utils.getApp().getApplicationContext().getSystemService(Context.CLIPBOARD_SERVICE);
        // 将文本内容放到系统剪贴板里。
        ClipData clipData = ClipData.newPlainText("newPlainTextLabel", result);
        cm.setPrimaryClip(clipData);
        if (isShowToast) {
            ToastUtils.make().setGravity(Gravity.CENTER, 0, 0);
            ToastUtils.showShort("复制成功~");
        }

    }

    /**
     * 工单派单详情 抽取的：如果是从工单统计 进入到工单详情的，那末就不给按钮修改为灰色和不可用的状态
     */
    public static void RoundTextViewButtonModify(RoundTextView button) {

        if (button != null) {

            Delivery.getInstance().post(new Runnable() {

                @Override
                public void run() {

                    button.getDelegate().setBackgroundColor(ColorUtils.getColor(R.color.gray14));
                    button.getDelegate().setBackgroundPressColor(ColorUtils.getColor(R.color.gray10));
                    button.getDelegate().setStrokeColor(ColorUtils.getColor(R.color.gray14));
                    button.getDelegate().setStrokePressColor(ColorUtils.getColor(R.color.gray10));

                    button.setOnClickListener(new ClickUtils.OnDebouncingClickListener() {
                        @Override
                        public void onDebouncingClick(View v) {
                            ToastUtils.showShort(R.string.statuscannotedit);
                            //LogUtils.d("itchen----消耗点击事件的内容");
                        }
                    });

                }
            });

        }
    }

    //是可用的状态的按钮通用
    public static void RoundTextViewButtonEnable(RoundTextView button) {

        Delivery.getInstance().post(new Runnable() {

            @Override
            public void run() {

                button.getDelegate().setBackgroundColor(ColorUtils.getColor(R.color.redcomm));
                button.getDelegate().setBackgroundPressColor(ColorUtils.getColor(R.color.red_pressed));
                button.getDelegate().setStrokeColor(ColorUtils.getColor(R.color.redcomm));
                button.getDelegate().setStrokePressColor(ColorUtils.getColor(R.color.red_pressed));


//                roundTextViewEditRightForCustomer.getDelegate().setBackgroundColor(ColorUtils.getColor(R.color.redcomm));
//                roundTextViewEditRightForCustomer.getDelegate().setBackgroundPressColor(ColorUtils.getColor(R.color.red_pressed));
//
//                roundTextViewEditRightForCustomer.getDelegate().setStrokeColor(ColorUtils.getColor(R.color.redcomm));
//                roundTextViewEditRightForCustomer.getDelegate().setStrokePressColor(ColorUtils.getColor(R.color.red_pressed));

//                button.setOnClickListener(new ClickUtils.OnDebouncingClickListener() {
//                    @Override
//                    public void onDebouncingClick(View v) {
//                        ToastUtils.showShort(R.string.statuscannotedit);
//                        //LogUtils.d("itchen----消耗点击事件的内容");
//                    }
//                });

            }
        });


    }

    //设置为白色的布局按钮
    public static void RoundTextViewButtonWhite(RoundTextView button) {

        Delivery.getInstance().post(new Runnable() {

            @Override
            public void run() {

                button.setTextColor(ColorUtils.getColor(R.color.redcomm));

                button.getDelegate().setBackgroundColor(ColorUtils.getColor(R.color.white));
                button.getDelegate().setBackgroundPressColor(ColorUtils.getColor(R.color.red_pressed));

                button.getDelegate().setStrokeColor(ColorUtils.getColor(R.color.redcomm));
                button.getDelegate().setStrokePressColor(ColorUtils.getColor(R.color.red_pressed));

//                roundTextViewEditRightForCustomer.getDelegate().setBackgroundColor(ColorUtils.getColor(R.color.redcomm));
//                roundTextViewEditRightForCustomer.getDelegate().setBackgroundPressColor(ColorUtils.getColor(R.color.red_pressed));

//                roundTextViewEditRightForCustomer.getDelegate().setStrokeColor(ColorUtils.getColor(R.color.redcomm));
//                roundTextViewEditRightForCustomer.getDelegate().setStrokePressColor(ColorUtils.getColor(R.color.red_pressed));

//                button.setOnClickListener(new ClickUtils.OnDebouncingClickListener() {
//                    @Override
//                    public void onDebouncingClick(View v) {
//                        ToastUtils.showShort(R.string.statuscannotedit);
//                        //LogUtils.d("itchen----消耗点击事件的内容");
//                    }
//                });

            }
        });

    }

    //设置为 红色 的布局按钮
    public static void RoundTextViewButtonRed(RoundTextView button) {

        Delivery.getInstance().post(new Runnable() {

            @Override
            public void run() {

                button.setTextColor(ColorUtils.getColor(R.color.white));

                button.getDelegate().setBackgroundColor(ColorUtils.getColor(R.color.redcomm));
                button.getDelegate().setBackgroundPressColor(ColorUtils.getColor(R.color.red_pressed));

                button.getDelegate().setStrokeColor(ColorUtils.getColor(R.color.redcomm));
                button.getDelegate().setStrokePressColor(ColorUtils.getColor(R.color.red_pressed));

//                roundTextViewEditRightForCustomer.getDelegate().setBackgroundColor(ColorUtils.getColor(R.color.redcomm));
//                roundTextViewEditRightForCustomer.getDelegate().setBackgroundPressColor(ColorUtils.getColor(R.color.red_pressed));

//                roundTextViewEditRightForCustomer.getDelegate().setStrokeColor(ColorUtils.getColor(R.color.redcomm));
//                roundTextViewEditRightForCustomer.getDelegate().setStrokePressColor(ColorUtils.getColor(R.color.red_pressed));

//                button.setOnClickListener(new ClickUtils.OnDebouncingClickListener() {
//                    @Override
//                    public void onDebouncingClick(View v) {
//                        ToastUtils.showShort(R.string.statuscannotedit);
//                        //LogUtils.d("itchen----消耗点击事件的内容");
//                    }
//                });

            }
        });


    }


    //圆角按钮的不可用
    public static void RoundTextViewButtonNotUse(RoundTextView button) {

        Delivery.getInstance().post(new Runnable() {

            @Override
            public void run() {

                button.getDelegate().setBackgroundColor(ColorUtils.getColor(R.color.black20));
                button.getDelegate().setBackgroundPressColor(ColorUtils.getColor(R.color.gray10));

                button.getDelegate().setStrokeColor(ColorUtils.getColor(R.color.black20));
                button.getDelegate().setStrokePressColor(ColorUtils.getColor(R.color.gray10));

//                roundTextViewEditRightForCustomer.getDelegate().setBackgroundColor(ColorUtils.getColor(R.color.gray14));
//                roundTextViewEditRightForCustomer.getDelegate().setBackgroundPressColor(ColorUtils.getColor(R.color.gray10));
//
//                roundTextViewEditRightForCustomer.getDelegate().setStrokeColor(ColorUtils.getColor(R.color.gray14));
//                roundTextViewEditRightForCustomer.getDelegate().setStrokePressColor(ColorUtils.getColor(R.color.gray10));

//                button.setOnClickListener(new ClickUtils.OnDebouncingClickListener() {
//                    @Override
//                    public void onDebouncingClick(View v) {
//                        ToastUtils.showShort(R.string.statuscannotedit);
//                        //LogUtils.d("itchen----消耗点击事件的内容");
//                    }
//                });

            }
        });


    }

    //和余额的比较内容。特别是比较  有欠费的情况，那么这个待支付的额度默认是余额。
    public static BigDecimal feeLiveBigDecimalCompareToBalance(BigDecimal balanceBigDecimal) {

        //默认一个返回的总额度
        BigDecimal numAmount = new BigDecimal(0.00);

        BigDecimal numZero = BigDecimal.ZERO;

        if (balanceBigDecimal != null) {

            if (balanceBigDecimal.compareTo(numZero) < 0) {
                numAmount = balanceBigDecimal.abs();
            }

        }

        return numAmount;
    }

    //生活缴费的按钮变更
    public static void RoundTextViewButtonModifyFeeLive(RoundTextView button, boolean isClick) {

        if (button != null) {

            Delivery.getInstance().post(new Runnable() {

                @Override
                public void run() {

                    if (isClick) {

                        //选中之后，文字设置为白色
                        button.setTextColor(ColorUtils.getColor(R.color.white));

                        button.getDelegate().setBackgroundColor(ColorUtils.getColor(R.color.buttonloginpress));
                        button.getDelegate().setBackgroundPressColor(ColorUtils.getColor(R.color.fee_tag_price));

                        button.getDelegate().setStrokeColor(ColorUtils.getColor(R.color.buttonloginpress));
                        button.getDelegate().setStrokePressColor(ColorUtils.getColor(R.color.fee_tag_price));

//                      button.setOnClickListener(new ClickUtils.OnDebouncingClickListener() {
//                        @Override
//                        public void onDebouncingClick(View v) {
//                            ToastUtils.showShort(R.string.statuscannotedit);
//                            //LogUtils.d("itchen----消耗点击事件的内容");
//                        }
//                    });

                    } else {

                        //没有选中，文字设置为黑色
                        button.setTextColor(ColorUtils.getColor(R.color.dark));

                        button.getDelegate().setBackgroundColor(ColorUtils.getColor(R.color.fee_tag_price));
                        button.getDelegate().setBackgroundPressColor(ColorUtils.getColor(R.color.gray30));

                        button.getDelegate().setStrokeColor(ColorUtils.getColor(R.color.fee_tag_price));
                        button.getDelegate().setStrokePressColor(ColorUtils.getColor(R.color.gray30));

//                      button.setOnClickListener(new ClickUtils.OnDebouncingClickListener() {
//                        @Override
//                        public void onDebouncingClick(View v) {
//                            ToastUtils.showShort(R.string.statuscannotedit);
//                            //LogUtils.d("itchen----消耗点击事件的内容");
//                        }
//                    });

                    }

                }
            });
        }
    }

    /**
     * 检查apk的安装包是否完整
     */
    public static boolean getUninatllApkInfo(Context context, String filePath) {

        boolean result = false;

        try {
            PackageManager pm = context.getPackageManager();
            // Log.e("archiveFilePath", filePath);
            PackageInfo info = pm.getPackageArchiveInfo(filePath, PackageManager.GET_ACTIVITIES);
            //String packageName = null;
            if (info != null) {
                //LogUtils.d("itchen---->能解析出来当前apk-->"+info.versionCode);
                result = true;
            }
        } catch (Exception e) {
            //LogUtils.d("itchen---->不能解析出来当前apk");
            result = false;
            // Log.e(TAG,***** 解析未安装的 apk 出现异常 *****+e.getMessage,e);
        }
        return result;
    }

    /**
     * apk下载的文件夹路径
     */
    public static File mkdirBluetooth(String fileDir) {

        try {
            // 创建目标目录
            File targetDir = new File(Utils.getApp().getExternalCacheDir().getAbsolutePath(), fileDir);//给一个路径
            //LogUtils.d("itchen--targetDir-" + targetDir);
            //itchen--targetDir-/storage/emulated/0/Android/data/com.dgj.propertyowner/cache/downapp

            if (!targetDir.exists()) {//如果不存在
                if (!targetDir.mkdirs()) return null;
            }
            // 返回目标目录文件
            return targetDir;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }


//    public static void alertToast(Context mContext,Activity mActivity){
//
//        //提示提交成功，然后1秒后关闭界面
//        AlertView mAlertView = new AlertView(StringUtils.getString(R.string.clearaddorsubmitsuretitletips), //
//                mActivity.getString(R.string.addsubmitsuccess), //
//                null, //
//                null, //
//                null, //
//                mActivity, //
//                AlertView.Style.Alert, //
//                null);
//        mAlertView.setCancelable(true).show();//
//
//        mCompositeDisposable.add(Observable.timer(ConstantApi.ALERTVIEW_TIME_DELAY, TimeUnit.MILLISECONDS)
//                .subscribeOn(AndroidSchedulers.mainThread())//
//                .observeOn(AndroidSchedulers.mainThread())//
//                //.compose(mActivity.bindUntilEvent(ActivityEvent.DESTROY))//
//                .subscribe(new Consumer<Long>() {
//                    @Override
//                    public void accept(Long aLong) throws Exception {
//
//                        if (mAlertView != null) {
//                            if (mAlertView.isShowing()) {
//                                mAlertView.dismiss();
//                                mAlertView = null;
//                            }
//                        }
//
//                        if (ActivityUtils.isActivityAlive(WorkDailyAddSubmitActivity.this)) {
//                            ActivityUtils.finishActivity(WorkDailyAddSubmitActivity.this);
//                        }
//
//                    }
//                }));
//
//    }


    //版本更新的弹窗：
    public static void showDownLoadDialog(final String _downLoadUrlCurrent, Activity _mActivity) {

        //点击边缘不可更改。要不要区分？强制更新、不强制更新。
        if (ActivityUtils.isActivityAlive(_mActivity)) {

            MaterialDialog materialDialogHasUpdateData = new MaterialDialog.Builder(_mActivity)
                    .title(R.string.updateinfotitle)
                    .titleColor(ContextCompat.getColor(Utils.getApp(), R.color.dark))
                    .content(StringUtils.getString(R.string.updateappinfo))
                    .contentColor(ContextCompat.getColor(Utils.getApp(), R.color.dark))
                    .positiveText(R.string.updateformserver)//右侧下载
                    //.positiveColor(ContextCompat.getColor(Utils.getApp(), R.color.red_normal))
                    .positiveColor(ContextCompat.getColor(Utils.getApp(), R.color.couponshop))
                    .negativeText(R.string.updatebuttoncancel)//左侧取消
                    .negativeColor(ContextCompat.getColor(Utils.getApp(), R.color.colormobutton))
                    //.neutralText(R.string.updatebuttoncancel)//
                    //.neutralColor(ContextCompat.getColor(Utils.getApp(), R.color.colormobutton))
                    .onPositive(new MaterialDialog.SingleButtonCallback() {
                        @Override
                        public void onClick(MaterialDialog dialog, DialogAction which) {

                            method_inside_download(_downLoadUrlCurrent, _mActivity);

                        }
                    })
                    .onNegative(new MaterialDialog.SingleButtonCallback() {
                        @Override
                        public void onClick(MaterialDialog dialog, DialogAction which) {
                            //取消的
//                            LogUtils.d(ConstantSign.LOGCAT_NOMAL + "取消的  按钮内容");
                        }
                    }).dismissListener(new DialogInterface.OnDismissListener() {
                        @Override
                        public void onDismiss(DialogInterface dialog) {
                            //LogUtils.d("itchen触发取消视图的事件dismissListener");
                        }
                    }).canceledOnTouchOutside(true).show();//这个可以随时获取就放开点击消失

            //materialDialogHasUpdateData.getTitleView().setTextSize(ResourceUtils.getDimenIdByName("font_14"));
            materialDialogHasUpdateData.getTitleView().setTextSize(14);
            materialDialogHasUpdateData.getActionButton(DialogAction.POSITIVE).setTextSize(15);

        }
    }

    //直接使用浏览器下载？
//    private static void method_app_look(String _downLoadUrlCurrent, Activity _mActivity){
//
//
//
//
//    }

    //直接执行下载
    public static void method_inside_download(String _downLoadUrlCurrent, Activity _mActivity) {

        //LogUtils.d("itchen--确定按钮");
//        mSession.setQuitUpdate(true);

        //2019年12月11日 这段代码暂时不用。
//        Intent updateIntent = new Intent();
//        updateIntent.setClass(SettingActivity.this, UpdateService.class);
//        updateIntent.putExtra(Parameterkey.nameapk, AppUtils.getAppName());
//        updateIntent.putExtra(Parameterkey.urlapk, _downLoadUrlCurrent);
//
//        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
//            startForegroundService(updateIntent);
//        } else {
//            startService(updateIntent);
//        }
//
//        //将来如果这一块有问题直接屏蔽即可
//        showProgressDialog();

        //使用浏览器下载 ：
        //弹窗其实是否打开链接
        final Intent intent = new Intent();
        intent.setAction(Intent.ACTION_VIEW);
        intent.setData(Uri.parse(_downLoadUrlCurrent));
        // 注意此处的判断intent.resolveActivity()可以返回显示该Intent的Activity对应的组件名
        // 官方解释 : Name of the component implementing an activity that can display the intent
        if (intent.resolveActivity(_mActivity.getPackageManager()) != null) {
            //final ComponentName componentName = intent.resolveActivity(getPackageManager());
            // 打印Log   ComponentName 到底是什么
            //Log.e(TAG, "componentName = " + componentName.getClassName());
            _mActivity.startActivity(Intent.createChooser(intent, StringUtils.getString(R.string.plesechooseintent)));

        } else {
            ToastUtils.showShort(R.string.nochooseappdownload);
        }

    }

    //-----------------------------------------------------------------------------------------------------------------------------------

    public static void method_open(Session _session, Activity _activityInstance) {

        //切换后门的代码

        //不论当前处于什么环境 只要操纵过后门，那么就标记true操作过-第一重要值，必须放在最先设置。
        MMKV.defaultMMKV().encode(ConstantSign.ISOPERATEDOOR, true);

        //取出本地存入的【当前正在用的环境】是什么环境
//        String environmentValue = MMKV.defaultMMKV().decodeString(ConstantApi.ENVIRONMENT);
        LogUtils.d("itchen---->当前【正在】处于的环境是--->" + MMKV.defaultMMKV().decodeString(ConstantSign.ENVIRONMENT));
        //itchen---->当前处于的环境是--->null

        if (!TextUtils.isEmpty(MMKV.defaultMMKV().decodeString(ConstantSign.ENVIRONMENT))) {
            //原始代码
            if (TextUtils.equals(MMKV.defaultMMKV().decodeString(ConstantSign.ENVIRONMENT), ApiService.VALUE_ENVIRONMENT_OFFICIAL)) {//official
                LogUtils.d("itchen=======================================>即将切换到 测试环境=====================================>");
                method_test(_session, _activityInstance);

            } else if (TextUtils.equals(MMKV.defaultMMKV().decodeString(ConstantSign.ENVIRONMENT), ApiService.VALUE_ENVIRONMENT_TEST)) {//test
                LogUtils.d("itchen=======================================>即将切换到 正式环境=====================================>");
                method_official(_session, _activityInstance);
            } else {
                //如果发现MMKV之中是空值，那么直接走正式环境的，避免出错
                LogUtils.d("itchen=============================MMKV->ENVIRONMENT 是null==========>控制-切换到 正式环境=====================================>");
                method_official(_session, _activityInstance);
            }

        } else {
//          LogUtils.d(ConstantApi.LOGCAT_NOMAL + "获取【当前所在的环境】为空值~");
            //如果发现MMKV之中是空值，那么直接走正式环境的，避免出错
            LogUtils.d("itchen=============================MMKV->ENVIRONMENT ==空值==>控制-切换到 正式环境=====================================>");
            method_official(_session, _activityInstance);
        }

//        if (ActivityUtils.isActivityExistsInStack(HomeMainFragmentActivity.class)) {
//            LogUtils.d("itchen---->HomeMainFragmentActivity 存在 堆栈之中");
//            //因为这里有可能没有进入【首页】，就切换环境，导致了直接崩溃，杀死首页是为了解决recyclerView的动画崩溃
//            ActivityUtils.finishActivity(HomeMainFragmentActivity.class);
//        }

        //在【关于我们界面】，如果是【已经登录状态】，还有一个切换环境的地方在【登录页面】
        if (_activityInstance instanceof AboutMeActivity) {

            Bundle extra_bundle = new Bundle();
            //标志是切换后门过来的；
            extra_bundle.putInt(ExtraKey.EXTRA_REQUEST_20401, ExtraValue.RESPONSE_20401);
            //直接跳转到该页面
            ActivityUtils.startActivity(extra_bundle, _activityInstance, LoginCarActivity.class);
            //设置退出登录
            //MMKV.defaultMMKV().encode(ConstantSign.P_ISLOGIN, false);
            //直接关闭该页面，打开登录页面
            ActivityUtils.finishActivity(_activityInstance);

        }

        LogUtils.d(ConstantSign.LOGCAT_NOMAL + "最终--切换环境完毕之后的 getPublic_url_prefix=baseUrl=>" + NetworkManager.getInstance().getPublic_url_prefix());
    }

    /**
     * 打开测试环境的逻辑
     *
     * @param _session
     * @param _activityInstance
     */
    public static void method_test(Session _session, Activity _activityInstance) {

        NetworkManager.getInstance().setReleaseInManager(false);//标志打开后门的首端地址信息。

        //测试环境的后门是 test 正式环境是 official,,打开测试环境那么就给环境标志为test
        MMKV.defaultMMKV().encode(ConstantSign.ENVIRONMENT, ApiService.VALUE_ENVIRONMENT_TEST);//

        switchBackDoor(_session, _activityInstance);

        //展示后门的baseUrl...
//        CommUtils.method_showAlertViewSingle(mActivityInstance, "是测试", NetworkManager.getInstance().getSystemConfig(), false);
        ToastUtils.showLong(_activityInstance.getString(R.string.is_office) + NetworkManager.getInstance().getSystemConfig());

        VibrateUtils.vibrate(1200);

    }

    /**
     * 打开正式环境的逻辑
     *
     * @param _session
     * @param _activityInstance
     */
    public static void method_official(Session _session, Activity _activityInstance) {

        NetworkManager.getInstance().setReleaseInManager(true);

        //如果关闭了后门则该值是true,标识切换到了正式环境
        //测试环境的后门是 test 正式环境是 official,,如果想打开正式环境，那么就给环境标志为正式
        MMKV.defaultMMKV().encode(ConstantSign.ENVIRONMENT, ApiService.VALUE_ENVIRONMENT_OFFICIAL);//

        switchBackDoor(_session, _activityInstance);

//      CommUtils.method_showAlertViewSingle(mActivityInstance, "是正式", NetworkManager.getInstance().getSystemConfig(), false);
        ToastUtils.showLong(_activityInstance.getString(R.string.is_test) + NetworkManager.getInstance().getSystemConfig());

        VibrateUtils.vibrate(1200);

    }

    //直接切换
    public static void switchBackDoor(Session mSession, Activity _activityInstance) {

        ClearAllOutData(mSession, _activityInstance, MMKV.defaultMMKV().decodeString(ConstantSign.P_INPUTNAMELASTTIME));

        //2017年修改因为切换后门导致首页三大页面无数据，应该是进入到类似第一次进入app的模式
        //EventBus.getDefault().post(new LocationEvent(ConstantApi.EVENT_NODATA_TO_LOCAITON));
        //跳转到登录界面。
        //mHandler.postDelayed(mRunnable, 600);

    }

    /**
     * 暂时先不做变更
     */
    public static final void getSystemConfig(final Activity _activity, final Session _session, ApiRequestSubListener<ArrayList<SystemConfigEntity>> _apiRequestSubListener) {

        //第一版本先这样写,避开使用blankj，因为审核不通过
        //if (_activity != null && ActivityUtils.isActivityAlive(_activity)) {
        if ((_activity != null) && (!_activity.isFinishing())) {

            HashMap<String, Object> hashMapParameter = new HashMap<>();
            hashMapParameter.put("", "");

            // itchenqi---gsonHashmap==>{"password":"RTEwQURDMzk0OUJBNTlBQkJFNTZFMDU3RjIwRjg4M0U\u003d","inputBox":"xj001","deviceToken":"AibPuJdhXUMNep_ZE-gCUc1KLWo6z5AxhgMC5xlKO4EW"}
            RequestBody requestBody = RequestBody.create(JSON.toJSONString(hashMapParameter, SerializerFeature.PrettyFormat, SerializerFeature.WriteMapNullValue), MediaType.parse(ApiService.HEADER_JSON));

            AddLogUpLoadInfo addLogUpLoadInfo = new AddLogUpLoadInfo();
            addLogUpLoadInfo.setActivity(_activity);
            addLogUpLoadInfo.setWhat(ConstantApi.GETSYSTEM_CONFIG);
            addLogUpLoadInfo.setUrlPath(ApiService.getConfigUrl);
            addLogUpLoadInfo.setRequestMethod(ConstantSign.REQUEST_METHOD_POST);
            addLogUpLoadInfo.setToastToUser(false);//不需要展示给用户的
            addLogUpLoadInfo.setHashMapParameter(hashMapParameter);

            //这里需要重新加载--这里内部还可以再组合
            NetworkManager.getInstance()//
                    .initRetrofitRxJava()//
                    .create(ApiService.class)//
                    .getConfig(requestBody)//
                    .compose(new ResponseTransformer<>(addLogUpLoadInfo,
                            _apiRequestSubListener))//
                    .flatMap(new Function<ArrayList<SystemConfigEntity>, ObservableSource<SystemConfigEntity>>() {
                        @Override
                        public ObservableSource<SystemConfigEntity> apply(ArrayList<SystemConfigEntity> systemConfigEntities) throws Exception {
                            return Observable.fromIterable(systemConfigEntities);
                        }
                    }).filter(new Predicate<SystemConfigEntity>() {
                        @Override
                        public boolean test(SystemConfigEntity systemConfigEntity) throws Exception {

                            //LogUtils.d("itchen----全部的回来的key值-->" + systemConfigEntity.getKey());

                            return TextUtils.equals(systemConfigEntity.getKey(), ConstantSign.GETCONFIG_PUBLIC_URL_PREFIX)//前缀  或者 下载地址
                                    || TextUtils.equals(systemConfigEntity.getKey(), ConstantSign.APP_UPDATE_ANDROID_DOWNLOAD_URL)//下载地址
                                    || TextUtils.equals(systemConfigEntity.getKey(), ConstantSign.GETCONFIG_CURRENCYSYMBOL);//动态的货币符号【业户信息-一键催缴用到】
                        }

                    }).subscribe(new Consumer<SystemConfigEntity>() {
                        @Override
                        public void accept(SystemConfigEntity systemConfigEntity) throws Exception {
                            //回来的key只内容
                            //String key = systemConfigEntity.getKey();
                            //LogUtils.d("itchen----过滤回来的key值-->" + systemConfigEntity.getKey());
                            //itchen----过滤回来的key值-->apk_download_url
                            //itchen----过滤回来的key值-->public_url_prefix
                            if (TextUtils.equals(systemConfigEntity.getKey(), ConstantSign.GETCONFIG_PUBLIC_URL_PREFIX)) {

                                //做异步请求
                                if (!TextUtils.isEmpty(systemConfigEntity.getValue())) {

                                    LogUtils.d("itchen---public_url_prefix------服务器响应的域名-systemConfigEntity.getValue()----->" + systemConfigEntity.getValue());
                                    //itchen---public_url_prefix------服务器响应的域名-systemConfigEntity.getValue()----->http://222.222.17.184:8990
                                    //MMKV.defaultMMKV().encode(ConstantApi.PUBLIC_URL_PREFIX, systemConfigEntity.getValue());//本地再存一份

                                    //直接整体的设置retrofit的baseurl
                                    // : 2022-11-03 19:02 设置baseurl的值内容
                                    if (_session != null) {
                                        _session.setPublic_url_prefix(systemConfigEntity.getValue());
                                    } else {//如果等于空要手动的给  setPublic_url_prefix 之中的3个逻辑执行了
                                        NetworkManager.getInstance().setPublic_url_prefix_form_getSystemConfig(systemConfigEntity.getValue());//内存里存一份
                                        MMKV.defaultMMKV().encode(ConstantSign.PUBLIC_URL_PREFIX, systemConfigEntity.getValue());//本地再存一份
                                        MMKV.defaultMMKV().encode(ConstantSign.PUBLIC_URL_PREFIX_LASTTIME, systemConfigEntity.getValue());
                                    }

                                    //先存入值内容 再获取token
                                    //获取token信息，获取完毕  public_url_prefix  之后立马获取token
                                    //相当于system是app第一个重要接口，token是第二个重要接口。
                                    //2022-6-13 审核被拒，这里也是需要判断 用户是否点击【同意】；
                                    getTokenInterface(systemConfigEntity.getValue(), _activity, _session);

                                } else {

                                    //如果发现是空的就取上一次的历史记录内的
                                    //默认是打包进去的正式环境的真的
                                    //LogUtils.d("itchen---public_url_prefix--上次的--->" + public_url_prefixLastTime);
                                    _session.setPublic_url_prefix(MMKV.defaultMMKV().decodeString(ConstantSign.PUBLIC_URL_PREFIX_LASTTIME, ApiService.VALUE_ENVIRONMENT_OFFICIAL));

                                }

                            } else if (TextUtils.equals(systemConfigEntity.getKey(), ConstantSign.APP_UPDATE_ANDROID_DOWNLOAD_URL)) {

                                //存入下载地址的值内容
                                if (!TextUtils.isEmpty(systemConfigEntity.getValue())) {

                                    //存入地址信息
                                    //2018年06月01日接口获取数据内容
                                    //http://wuyeapi.91dgj.com/download/apk/PropertyOwner4.apk

                                    //"key": "apk_download_url",
                                    //"value": "http://222.222.17.184:8881/download/apk/PropertyOwner4.apk"

                                    //http://dev.api.91dgj.com/h5/app/android/DaGuanJiaGitSource27.apk
                                    //String curVersion = app_update_android_download_url.substring(app_update_android_download_url.lastIndexOf("/")+1, app_update_android_download_url.length());
                                    //LogUtils.d("itchen-curVersion--"+curVersion);
                                    //LogUtils.d("itchen--服务器给的下载地址-->app_update_android_download_url=>" + app_update_android_download_url);
                                    //itchen--服务器给的下载地址-->app_update_android_download_url=>http://wuyeapi.91dgj.com/resource/app/apk/20190125193414147/社区管家2.apk

                                    //app_update_android_download_url=>http://222.222.17.184:8881/resource/app/apk/20200324101807204/社区管家21.apk

                                    _session.setDownloadurlCurrent(systemConfigEntity.getValue());

                                } else {

                                    // : 2022-10-26 15:08 添加上传日志  下载地址为空

                                }

                            } else if (TextUtils.equals(systemConfigEntity.getKey(), ConstantSign.GETCONFIG_CURRENCYSYMBOL)) {

                                //"key": "currencySymbol",
                                //"value": "￥"
                                //LogUtils.d("itchen--->打印的货币符号：" + valueServer);

                                //存入货币符号内容。
                                _session.setCurrencySymbol(systemConfigEntity.getValue());

                            }

                        }

                    }, new ErrorConsumer() {
                        @Override
                        protected void error(ApiException e) {

                            if (e != null) {
                                LogUtils.d("itchen---->走到-ErrorConsumer-的报错地方=>" + e.getDisplayMessage());
                                //java.util.ArrayList cannot be cast to com.dgj.propertysmart.response.SystemConfigEntity
                            }
                        }
                    });

        }

    }

    /**
     * 该APP第二个重要接口获取token
     */
    public static final void getTokenInterface(String requestBaseUrl, Activity _activity, final Session _session) {

        /*
         * if (!TextUtils.isEmpty(uuid)) { uuid是空的怎么办 String requestUrl =
         * "http://192.168.1.86:8080/v1/user/token/" + uuid; }
         */
        // String requestUrl = "http://192.168.1.253:8084/v1/user/token/" +uuid;

        //拆解代码
        //String uuid = PreferenceManager.getInstance().getSaveStringData(ConstantApi.P_UUID, "");
        //String requestUrl = Constants.getInstance().getToken() + uuid;

        //2018年06月07日优化该模块内容
        //String requestUrl = Constants.getInstance().getToken() + PreferenceManager.getInstance().getSaveStringData(ConstantApi.P_UUID, "");

        //if (_activity != null && ActivityUtils.isActivityAlive(_activity)) {
//        if (_activity != null && !_activity.isFinishing()) {

//            try {
//
//                //do
//                if (TextUtils.isEmpty(MMKV.defaultMMKV().decodeString(ConstantApi.P_UUID, ""))) {//怕就怕在这个没有取到就执行了gettoken
//
//                    //在这里做一次判断即可；
//                    if (MMKV.defaultMMKV().decodeBool(ConstantApi.P_SECRECYTURL_AGREE)) {
//                        if (!TextUtils.isEmpty(DeviceUtils.getUniqueDeviceId())) {
//                            _session.setUuid(DeviceUtils.getUniqueDeviceId());
//                        } else {
//                            _session.setUuid(DeviceUtils.getAndroidID());
//                        }
//                    } else {
//                        //LogUtils.d(ConstantApi.LOGCAT_NOMAL + "getTokenInterface 内部的 未能获取到用户-【同意】获取 uuid");
//                    }
//                }
//
//            } catch (Exception e) {
//                //catch
//                e.printStackTrace();
//            }

        //这里重新做一次拦截
        //-----------------------------------------------------------------------------------------------
        //改为从内存之中变量取值，这样比较快速；
        if (TextUtils.isEmpty(MMKV.defaultMMKV().decodeString(ConstantSign.P_UUID_UNIQUEDEVICEID_ANDROIDID, DeviceUtils.getUniqueDeviceId()))) {

            //LogUtils.d("itchen----发现 DeviceUtils.getAndroidID是空的");
            String mUniqueDeviceId = "";

            try {
                //do
                if (MMKV.defaultMMKV().decodeBool(ConstantSign.P_SECRECYTURL_AGREE)) {
                    mUniqueDeviceId = DeviceUtils.getUniqueDeviceId();
                    //LogUtils.d("itchen--try-getUniqueDeviceId-取到的设备uuid是--->" + mUniqueDeviceId);
                    if (!TextUtils.isEmpty(mUniqueDeviceId)) {
                        if (_session != null) {
                            _session.setUuid(mUniqueDeviceId);
                        } else {
                            MMKV.defaultMMKV().encode(ConstantSign.P_UUID_UNIQUEDEVICEID_ANDROIDID, mUniqueDeviceId);
                        }
                    } else {
                        if (MMKV.defaultMMKV().decodeBool(ConstantSign.P_SECRECYTURL_AGREE)) {

                            if (_session != null) {
                                _session.setUuid(DeviceUtils.getAndroidID());
                            } else {
                                MMKV.defaultMMKV().encode(ConstantSign.P_UUID_UNIQUEDEVICEID_ANDROIDID, DeviceUtils.getAndroidID());
                            }
                            //LogUtils.d("itchen--try-getAndroidID-取到的设备uuid是--->" + mUniqueDeviceId);
                        }
                    }
                } else {
                    //LogUtils.d("itchen----用户没有-点击【同意】");
                }

            } catch (Exception e) {
                //直接读取 androidid 作为填充
                if (MMKV.defaultMMKV().decodeBool(ConstantSign.P_SECRECYTURL_AGREE)) {
                    if (_session != null) {
                        _session.setUuid(DeviceUtils.getAndroidID());
                    } else {
                        MMKV.defaultMMKV().encode(ConstantSign.P_UUID_UNIQUEDEVICEID_ANDROIDID, DeviceUtils.getAndroidID());
                    }
                }
                //catch
                e.printStackTrace();
                //LogUtils.d("itchen--catch--取到的设备uuid是--->" + DeviceUtils.getAndroidID());
            }

        } else {
            LogUtils.d("itchen---取到的设备uuid是- 不是空-正常执行 getToken 接口");
        }

        //-----------------------------------------------------------------------------------------------
        if (TextUtils.isEmpty(requestBaseUrl)) {//这里再次做一次判断；
            requestBaseUrl = NetworkManager.getInstance().getPublic_url_prefix();
        }
        //-----------------------------------------------------------------------------------------------

        HashMap<String, Object> hashMap = new HashMap<>();
        hashMap.put(Parameterkey.uuid, Parameterkey.TOKEN_PREFIX + MMKV.defaultMMKV().decodeString(ConstantSign.P_UUID_UNIQUEDEVICEID_ANDROIDID, DeviceUtils.getUniqueDeviceId()));

        //get方式不需要转换json
        AddLogUpLoadInfo addLogUpLoadInfo = new AddLogUpLoadInfo();
        addLogUpLoadInfo.setActivity(_activity);
        addLogUpLoadInfo.setWhat(ConstantApi.WHAT_GETTOKEN);
        addLogUpLoadInfo.setUrlPath(ApiService.getTokenUrl);
        addLogUpLoadInfo.setRequestMethod(ConstantSign.REQUEST_METHOD_GET);
        addLogUpLoadInfo.setToastToUser(false);//不需要展示给用户的
        addLogUpLoadInfo.setHashMapParameter(hashMap);//是get接口

//            String requestUrl = requestBaseUrl + "/pub/v1/token/getToken/" //
//                    + "CloudSteward_" + //
//                    MMKV.defaultMMKV().decodeString(ConstantApi.P_UUID_UNIQUEDEVICEID_ANDROIDID);//

        //直接使用retrofit做改造  传参是添加了前缀之后的uuid
        NetworkManager.getInstance().initRetrofitRxJava()//
                .create(ApiService.class)//
                .getToken(Parameterkey.TOKEN_PREFIX + //
                        MMKV.defaultMMKV().decodeString(ConstantSign.P_UUID_UNIQUEDEVICEID_ANDROIDID, DeviceUtils.getUniqueDeviceId()))//这种是指定url
                .compose(new ResponseTransformer<>(addLogUpLoadInfo,//
                        new ApiRequestSubListener<String>() {//
                            @Override
                            public void handlerSomeThingNotSuccessDataForItSelf(int what_method, String serverCode, String serverMessage) {
                                super.handlerSomeThingNotSuccessDataForItSelf(what_method, serverCode, serverMessage);
                            }
                        })).subscribe(new Consumer<String>() {

                    @Override
                    public void accept(String stringHttpEntityProperty) throws Exception {
//                            {
//                                    "code":"20000",
//                                    "data":"00b6e856ad2af19625081756b39ca577",
//                                    "message":"success"
//                            }
                        //这里token真实取值
                        if (!TextUtils.isEmpty(stringHttpEntityProperty)) {

                            MMKV.defaultMMKV().encode(ConstantSign.P_TOKEN, stringHttpEntityProperty);

                            //简写
                            if (_session != null) {
                                _session.setToken(stringHttpEntityProperty);
                            } else {
                                //如果session是空值，那么需要人为的执行如下2个逻辑；
                                MMKV.defaultMMKV().encode(ConstantSign.P_TOKEN, stringHttpEntityProperty);
                                SPUtils.getInstance().put(ConstantSign.SP_TOKEN, stringHttpEntityProperty);
                            }

                            LogUtils.d("itchen-getToken接口返回的token--->" + stringHttpEntityProperty);
                            //格式是：b922596a630ee9c65d9d81a5c494a505

                            //获取完毕

                        } else {

                            //获取的token值内容是空的；
                            HashMap<String, Object> hashMapParameter = new HashMap<>();
                            hashMapParameter.put(ConstantSign.ADDLOG_KEY, Parameterkey.TOKEN_PREFIX +//
                                    MMKV.defaultMMKV().decodeString(ConstantSign.P_UUID_UNIQUEDEVICEID_ANDROIDID,//
                                            DeviceUtils.getUniqueDeviceId()));//

                            String jsonObjectString = JSON.toJSONString(hashMapParameter);

                            CommUtils.addLog(_activity,//
                                    addLogUpLoadInfo.getUrlPath(),//
                                    addLogUpLoadInfo.getRequestMethod(),//
                                    jsonObjectString,//
                                    CommUtils.addLogFormatCodeMessage(ConstantSign.RESPONSE_20000, //
                                            "-token值内容是空" + "-token值内容是空"));//
                        }
                    }
                }, new ErrorConsumer() {
                    @Override
                    protected void error(ApiException e) {
                        //报错的上传
                    }
                });

//        }else{
//            LogUtils.d(ConstantSign.LOGCAT_NOMAL+"获取token接口发现 有空的 activity");
//        }
    }


    /**
     * 用户协议的  这个应该是做成加载本地即可
     */
    public static void methodAgreementUrl_loadLocal(Context _context, String titleTop) {

        //跳转到一个H5界面即可
        Bundle extra_bundle = new Bundle();
        extra_bundle.putInt(ExtraKey.EXTRA_JUMPFROM_WHERE, ExtraValue.WHAT_TEXTAGREEMENTURL_LOADLOCAL);

        Intent intentToAgree = new Intent(_context, WebViewAboriginalActivity.class);
        intentToAgree.putExtras(extra_bundle);

        _context.startActivity(intentToAgree);

    }


    /**
     * 用户协议 的通用方法
     */
    public static void methodAgreementUrl(Context _context) {

//        Bundle bundle_extra = new Bundle();
//        //bundle_extra.put;
//        bundle_extra.putString(ConstantApi.EXTRA_CATEGORY_NAME, ConstantApi.TEXTURL_USER_AGREEMENT);//用户协议
//        bundle_extra.putInt(ConstantApi.EXTRA_WEBVIEW_FLAG, ConstantApi.WHAT_TEXTAGREEMENTURL);//用户协议标识
//        //投诉 建议 的界面内容。
//        ActivityUtils.startActivity(bundle_extra, WebViewNormalActivity.class);

        //跳转到一个H5界面即可
//        Bundle extra_bundle = new Bundle();
//        extra_bundle.putInt(ExtraKey.EXTRA_JUMPFROM_WHERE, ExtraValue.WHAT_TEXTAGREEMENTURL);
//        Intent intentToAgree = new Intent(_context, WebViewAboriginalActivity.class);
//        intentToAgree.putExtras(extra_bundle);
//        _context.startActivity(intentToAgree);
//        //ActivityUtils.startActivity(extra_bundle, WebViewAboriginalActivity.class);


        // Bundle bundle_extra = new Bundle();
//        //bundle_extra.put;
//        bundle_extra.putString(ConstantApi.EXTRA_CATEGORY_NAME, ConstantApi.TEXTURL_USER_AGREEMENT);//用户协议
//        bundle_extra.putInt(ConstantApi.EXTRA_WEBVIEW_FLAG, ConstantApi.WHAT_TEXTAGREEMENTURL);//用户协议标识
//        //投诉 建议 的界面内容。
//        ActivityUtils.startActivity(bundle_extra, WebViewNormalActivity.class);

        //跳转到一个H5界面即可
        Bundle extra_bundle = new Bundle();
        extra_bundle.putInt(ExtraKey.EXTRA_JUMPFROM_WHERE, ConstantApi.WHAT_TEXTAGREEMENTURL);
        extra_bundle.putInt(ExtraKey.EXTRA_WEBVIEW_FLAG, ConstantApi.WHAT_TEXTAGREEMENTURL);
        //2023-11-17 09:30:53 添加 标题头
        extra_bundle.putString(ExtraKey.EXTRA_CATEGORY_NAME, _context.getResources().getString(R.string.web_title_agreenurl));

//        Intent intentToAgree = new Intent(_context, WebViewAboriginalActivity.class);
        Intent intentToAgree = new Intent(_context, WebViewNormalActivity.class);

        intentToAgree.putExtras(extra_bundle);

        _context.startActivity(intentToAgree);

        //ActivityUtils.startActivity(extra_bundle, WebViewAboriginalActivity.class);

    }


    /**
     * 用户隐私政策的通用方法
     */
    public static void methodSecrecytUrl(Context _context) {

//        Bundle bundle_extra = new Bundle();
//        //bundle_extra.put;
//        bundle_extra.putString(ConstantApi.EXTRA_CATEGORY_NAME, ConstantApi.TEXTURL_PRIVACY_POLICY);//用户协议
//        bundle_extra.putInt(ConstantApi.EXTRA_WEBVIEW_FLAG, ConstantApi.WHAT_TEXTSECRECYTURL);//用户协议标识
//        //投诉 建议 的界面内容。
//        ActivityUtils.startActivity(bundle_extra, WebViewNormalActivity.class);

//        Bundle extra_bundle = new Bundle();
//        extra_bundle.putInt(ExtraKey.EXTRA_JUMPFROM_WHERE, ExtraValue.WHAT_TEXTSECRECYTURL);
//
//        //ActivityUtils.startActivity(extra_bundle, WebViewAboriginalActivity.class);
//
//        Intent intentToSecrecy = new Intent(_context, WebViewAboriginalActivity.class);
//        intentToSecrecy.putExtras(extra_bundle);
//
//        _context.startActivity(intentToSecrecy);


        Bundle extra_bundle = new Bundle();
        extra_bundle.putInt(ExtraKey.EXTRA_JUMPFROM_WHERE, ConstantApi.WHAT_TEXTSECRECYTURL);
        extra_bundle.putInt(ExtraKey.EXTRA_WEBVIEW_FLAG, ConstantApi.WHAT_TEXTSECRECYTURL);//用户协议标识
        //隐私政策的标题
        extra_bundle.putString(ExtraKey.EXTRA_CATEGORY_NAME, _context.getResources().getString(R.string.web_title_secrecy));

        //ActivityUtils.startActivity(extra_bundle, WebViewAboriginalActivity.class);

//        Intent intentToSecrecy = new Intent(_context, WebViewAboriginalActivity.class);
        Intent intentToSecrecy = new Intent(_context, WebViewNormalActivity.class);
        intentToSecrecy.putExtras(extra_bundle);

        _context.startActivity(intentToSecrecy);


    }

    /**
     * 用户隐私政策的 加载本地的方法 通用，只有在首次安装的时候才使用。
     */
    public static void methodSecrecytUrl_loadLocal(Context _context) {

//        Bundle bundle = new Bundle();
//        bundle.putString(ConstantApi.EXTRA_CATEGORY_NAME, titleTop);
//        bundle.putString(ConstantApi.ISJUMPFROM_HOMETOP_TITLE, titleTop);
//        //设置是隐私政策通用的方法：
//        bundle.putInt(ConstantApi.EXTRA_WEBVIEW_FLAG, ConstantApi.WHAT_TEXTSECRECYTURL);
//        //2019年原始的代码是供销便利和商品详情通用的一个界面
//        ActivityUtils.startActivity(bundle, WebViewNormalActivity.class);

        Bundle extra_bundle = new Bundle();
        extra_bundle.putInt(ExtraKey.EXTRA_JUMPFROM_WHERE, ExtraValue.WHAT_TEXTSECRECYTURL_LOADLOCAL);

        //ActivityUtils.startActivity(extra_bundle, WebViewAboriginalActivity.class);
        Intent intentToSecrecy = new Intent(_context, WebViewAboriginalActivity.class);
        intentToSecrecy.putExtras(extra_bundle);

        _context.startActivity(intentToSecrecy);

    }

    /**
     * 获取服务器端下载链接之中的最新版本号
     */
    public static int getServiceVersionCode(Session _session) {

        //原始代码:如下一整块
        //String downLoadUrlLastInterception = mSession.getDownloadurlPre();//上一次安装apk 静态写入本地的：社区管家1.apk
        //LogUtils.d("itchen-->downLoadUrlLastInterception==>"+downLoadUrlLastInterception);
        //itchen-->downLoadUrlLastInterception==>社区管家1.apk

        String _downLoadUrlCurrent = _session.getDownloadurlCurrent();//本次服务器返回来的
        //LogUtils.d("itchen-->downLoadUrlCurrent==>"+downLoadUrlCurrent);
        //itchen-->downLoadUrlCurrent==>http://wuyeapi.91dgj.com/resource/app/apk/20190125163745544/社区管家2.apk

        //2018年06月11日发现过一个这样的情况。链接后半部分是null
        //"value": "http://222.222.17.184:8881/resource/null"
        //除掉下载链接后边的应用名称。
        //第一步截取完整链接：如下
        //String test  =  "http://wuyeapi.91dgj.com/resource/app/apk/20190125163745544/社区管家42.apk";
        //测试代码
        //String substring1 = downLoadUrlCurrentInterception.substring(//
        //downLoadUrlCurrentInterception.lastIndexOf(AppUtils.getAppName()), downLoadUrlCurrentInterception.length());//

        if (!TextUtils.isEmpty(_downLoadUrlCurrent)) {

            String downLoadUrlCurrentInterception = _downLoadUrlCurrent.substring(//
                    _downLoadUrlCurrent.lastIndexOf("/") + 1);//社区管家140.apk
//            LogUtils.d("itchen--截取之后的downLoadUrlCurrentInterception=>" + downLoadUrlCurrentInterception);//社区管家42.apk
//            itchen--截取之后的downLoadUrlCurrentInterception=>社区管家2.apk
            //LogUtils.d(ConstantSign.LOGCAT_NOMAL+"downLoadUrlCurrentInterception--长度->"+downLoadUrlCurrentInterception.length());

            //第二步截取掉app的名称   
//            String subStringAppName = downLoadUrlCurrentInterception.substring(AppUtils.getAppName().length());//
            String subStringAppName = downLoadUrlCurrentInterception.substring(AppUtils.getAppName().length());

//            if (downLoadUrlCurrentInterception.startsWith("e")){
//                // : 2023-08-23 17:25 APP名称的长度;
//                subStringAppName = downLoadUrlCurrentInterception.substring(AppUtils.getAppName().length());
//            }else if(downLoadUrlCurrentInterception.startsWith("汽车员工端")){
//                subStringAppName = downLoadUrlCurrentInterception.substring(5);
//            }
//            LogUtils.d("itchen--截取掉app名称之后subStringAppName=>" + subStringAppName);//42.apk
//            itchen--截取掉app名称之后subStringAppName=>2.apk

            //第三步 做分割
            String[] subStringSplist = subStringAppName.split("\\.");
            /*for (int i = 0; i < subStringSplist.length; i++) {
             LogUtils.d("itchen-->最终分割="+subStringSplist[i]);
             //42
             //apk
             }*/
            //==========================================================================================
            //String subString3 = subString2.substring(subString2.lastIndexOf("."),);
            //LogUtils.d("itchen---subString3="+subString3);//.apk
            //LogUtils.d("itchen---getServiceVersionCode=" + subStringSplist[0]);
            //==========================================================================================
            return Integer.parseInt(subStringSplist[0]);

        }

        return 0;
    }

    /**
     * 全部的弹窗提示 从10001-29999
     */
    public static void errorAlertViewFullAll(Context _context,//
                                             int _statusCode,//
                                             String _message) {
        if (ConstantApi.RESPONSE_10001 <= _statusCode && _statusCode <= ConstantApi.RESPONSE_19999) {
            //表示系统级错误不向用户展示错误信息.自己做处理.
//            CommUtils.handlerLog(_statusCode, _message);
            method_showAlertViewSingle(_context, "提示", "错误码=" + _statusCode + ":" + _message, false);

        } else if (ConstantApi.RESPONSE_20001 <= _statusCode && _statusCode <= ConstantApi.RESPONSE_29999) {
            if (TextUtils.equals(String.valueOf(_statusCode), ConstantSign.RESPONSE_20401)) {
                //跳转到登录界面的处理
                //CommUtils.loginInfoOutLogic(_context, _message);
            } else {
                //表示服务级错误向用户展示错误信息。
                //判断该类是否是在顶部，如果在顶部就展示提示。如果不在顶部，则不提示???
                method_showAlertViewSingle(_context, "提示", _message, false);
            }
        }
    }

    /**
     * 10001-19999报错日志处理
     */
    public static void handlerLog(String code, String logMessage) {
        LogUtils.d("itchen--logMessage-10001-19999-->错误码" + code + "--日志信息==>" + logMessage);
    }


    /**
     * 统一处理跳转到商品详情界面
     * 2018年可能需要对这一块做点改造，因为有进入购物车从哪儿来到哪儿去
     */
    //public static void intentToWebDetailGoods(Activity _activity,ShopCartBean shopCartBean) {
    public static void intentToWebDetailGoods(ShopCartBean shopCartBean) {

        Bundle bundle = new Bundle();

        GoodsBean goodsBean = new GoodsBean();
        goodsBean.setProductId(shopCartBean.getProductId());
        goodsBean.setProductFullName(shopCartBean.getProductFullName());
        goodsBean.setAvailableStore(shopCartBean.getAvailableStore());//获取可用库存

        bundle.putParcelable(ExtraKey.EXTRA_PRODUCTBEAN, goodsBean);

        //第一种方式
        ActivityUtils.startActivity(bundle, WebGoodDetaillActivity.class);

        //第二种方式
        //ActivityUtils.startActivity(bundle,_activity,WebGoodDetaillActivity.class);
        //LogUtils.d("itchen------------------------intentToWebDetailGoods");

    }

    //给车辆品牌排序，按照英文的排序；
    public static void CollectionsSort_CarBrandLargeCategory_UK(ArrayList<CarBrandLargeCategory> mDataResources_carBrandLarge) {
        //参考
        //https://blog.csdn.net/Romantic_321/article/details/116595115
        Collections.sort(mDataResources_carBrandLarge, new Comparator<CarBrandLargeCategory>() {
            public int compare(CarBrandLargeCategory o1, CarBrandLargeCategory o2) {
                String s1 = o1.getCarBrandName();
                String s2 = o2.getCarBrandName();

                //如需倒序则对排序过的集合进行翻转
//                Collections.reverse(list);

                //按照英文名称排序；
                //该排序为正序排序，如果倒序排序则将compare中的s2和s1互换位置
                return Collator.getInstance(Locale.UK).compare(s1, s2);
            }
        });

    }

    //给车辆品牌排序，按照汉字的排序；
    public static void CollectionsSort_CarBrandLargeCategory_CHINA(ArrayList<CarBrandLargeCategory> mDataResources_carBrandLarge) {
//参考
        //https://blog.csdn.net/Romantic_321/article/details/116595115
        //按照名称排序
        Collections.sort(mDataResources_carBrandLarge, new Comparator<CarBrandLargeCategory>() {
            @Override
            public int compare(CarBrandLargeCategory o1, CarBrandLargeCategory o2) {
                //排序规则：按照汉字拼音首字母排序
                Comparator<Object> com = Collator.getInstance(java.util.Locale.CHINA);
                //该排序为正序排序，如果倒序排序则将compare中的01和02互换位置
                return com.compare(o1.getCarBrandName(), o2.getCarBrandName());
            }
        });

    }

    //给车系按照 英文排序
    public static void CollectionsSort_CarBrandSeriesLineSmallCategory_UK(ArrayList<CarBrandSeriesLineSmallCategory> mDataResources_carBrandSeriesList) {
//参考
        //https://blog.csdn.net/Romantic_321/article/details/116595115
        Collections.sort(mDataResources_carBrandSeriesList, new Comparator<CarBrandSeriesLineSmallCategory>() {
            public int compare(CarBrandSeriesLineSmallCategory o1, CarBrandSeriesLineSmallCategory o2) {
                String s1 = o1.getCarSeriesName();
                String s2 = o2.getCarSeriesName();

                //如需倒序则对排序过的集合进行翻转
//                Collections.reverse(list);
                //按照英文名称排序；
                //该排序为正序排序，如果倒序排序则将compare中的s2和s1互换位置
                return Collator.getInstance(Locale.UK).compare(s1, s2);
            }
        });

    }

    //给车系按照 中文排序
    public static void CollectionsSort_CarBrandSeriesLineSmallCategory_CHINA(ArrayList<CarBrandSeriesLineSmallCategory> mDataResources_carBrandSeriesList) {
//参考
        //https://blog.csdn.net/Romantic_321/article/details/116595115
        Collections.sort(mDataResources_carBrandSeriesList, new Comparator<CarBrandSeriesLineSmallCategory>() {
            public int compare(CarBrandSeriesLineSmallCategory o1, CarBrandSeriesLineSmallCategory o2) {
                String s1 = o1.getCarSeriesName();
                String s2 = o2.getCarSeriesName();
                //该排序为正序排序，如果倒序排序则将compare中的s2和s1互换位置
                return Collator.getInstance(Locale.CHINA).compare(s1, s2);
            }
        });

    }

    /**
     * 链接跳转的弹窗
     */
    public static void linkJumpDialogSignature(Context mContext, Activity mActivity, String _contentResult) {

        new MaterialDialog.Builder(mContext)//
                .title(mContext.getResources().getString(R.string.title_dialog_signature))//企业认证
                .content(mContext.getResources().getString(R.string.title_dialog_des) + _contentResult)//该链接将跳转到外部浏览器页面：
                .positiveText(mContext.getResources().getString(R.string.open_links_dialog_des))//打开链接
                .negativeText(mContext.getResources().getString(R.string.close_links_dialog_des))//关闭
                .neutralText(mContext.getResources().getString(R.string.copy_links_dialog_des))//复制链接
                .onPositive(new MaterialDialog.SingleButtonCallback() {//
                    @Override
                    public void onClick(@NonNull MaterialDialog dialog, @NonNull DialogAction which) {

                        //弹窗其实是否打开链接
                        final Intent intent = new Intent();
                        intent.setAction(Intent.ACTION_VIEW);
                        intent.setData(Uri.parse(_contentResult));
                        // 注意此处的判断intent.resolveActivity()可以返回显示该Intent的Activity对应的组件名
                        // 官方解释 : Name of the component implementing an activity that can display the intent
                        if (intent.resolveActivity(mActivity.getPackageManager()) != null) {

                            //final ComponentName componentName = intent.resolveActivity(getPackageManager());
                            // 打印Log   ComponentName 到底是什么
                            //Log.e(TAG, "componentName = " + componentName.getClassName());

                            mActivity.startActivity(Intent.createChooser(intent, mContext.getResources().getString(R.string.copy_links_dialog_des)));//请选择浏览器

                        } else {
                            ToastUtils.showShort(mContext.getResources().getString(R.string.open_links_dialog_noapp));//没有匹配的程序打开该链接
                        }

                    }
                })
                .onNeutral(new MaterialDialog.SingleButtonCallback() {
                    @Override
                    public void onClick(@NonNull MaterialDialog dialog, @NonNull DialogAction which) {
                        methodCopyClip(_contentResult, true);
                    }
                })
                .onNegative(new MaterialDialog.SingleButtonCallback() {
                    @Override
                    public void onClick(@NonNull MaterialDialog dialog, @NonNull DialogAction which) {
                        methodCopyClip(_contentResult, true);
                    }
                })
                .cancelable(true)
                .show();//

    }

    //扫描的是其他的文本内容
    public static void textJumpDialog(Context mContext, Activity mActivity, String _contentResult) {

        new MaterialDialog.Builder(mContext)
                .title("扫描内容")//
                .content(_contentResult)//
                .positiveText("复制文本")//
                .negativeText("关闭")//
                .onPositive(new MaterialDialog.SingleButtonCallback() {
                    @Override
                    public void onClick(@NonNull MaterialDialog dialog, @NonNull DialogAction which) {

                        //LogUtils.d("复制文本");
                        // 从API11开始android推荐使用android.content.ClipboardManager
                        // 为了兼容低版本我们这里使用旧版的android.text.ClipboardManager，虽然提示deprecated，但不影响使用。
                        ClipboardManager cm = (ClipboardManager) mContext.getSystemService(Context.CLIPBOARD_SERVICE);
                        // 将文本内容放到系统剪贴板里。
                        ClipData clipData = ClipData.newPlainText("newPlainTextLabel", _contentResult);
                        cm.setPrimaryClip(clipData);
                        //CommUtils.displayToastLong(HomeMainActivity.this, "复制成功");

                        ToastUtils.make().setGravity(Gravity.CENTER, 0, 0);
                        ToastUtils.showShort("复制成功~");

                    }
                })
                .onNegative(new MaterialDialog.SingleButtonCallback() {
                    @Override
                    public void onClick(@NonNull MaterialDialog dialog, @NonNull DialogAction which) {
                        //LogUtils.d("关闭弹窗");
                    }
                })
                .cancelable(true)
                .show();//

    }

    //直接拨打电话的能力
//    private void clickButton_toCallPhone(Activity _activity, String mPhoneNumber) {
//
//        CommUtils.checkDialog(mAlertView);
//
//        //二次确认弹窗提示
//        mAlertView = new AlertView(ConstantSign.ALERTVIEW_TITLE_FOR_PHONE,//
//                mPhoneNumber, //
//                ConstantSign.ALERTVIEW_LEFT_CANCEL,//
//                new String[]{ConstantSign.ALERTVIEW_RIGHT_COPY_INFORMATION}, //
//                null, //
//                _activity, //
//                AlertView.Style.Alert,//
//                new com.ygxsk.carhome.alertview.OnItemClickListener() {
//                    @Override
//                    public void onItemClick(Object o, int position) {
//
//                        if (position != AlertView.CANCELPOSITION) {
//
//                            if (!TextUtils.isEmpty(mPhoneNumber)) {
//                                _activity.startActivity(CommUtils.callThePhoneNumAction_dial(mPhoneNumber));
//                            } else {
//                                ToastUtils.showShort(R.string.hasfailgetphonenumber);
//                            }
//
//                        }
//                    }
//                }
//        );
//
//        mAlertView.setCancelable(true).show();
//
//    }

    /**
     * 添加查看大图功能
     */
    public static void methodBigImageView(Activity mActivity, String resultLoadImage) {

        if ((mActivity != null) && (ActivityUtils.isActivityAlive(mActivity))) {

            ArrayList<String> arrayList = new ArrayList<>();
            arrayList.add(resultLoadImage);
            //LogUtils.d("itchen---->该图片的链接是-->"+resultLoadImage);
            //2018年03月17日重新修改
            Album.gallery(mActivity)//
                    .checkedList(arrayList)//传递的是查看图片的链接。
                    //.currentPosition(position)//记录位置？
                    //.navigationAlpha(80)//
                    //.checkedList(arrayList)
                    /*.itemLongClick(new ItemAction<String>() {//长按的时候发现弹窗在Activity之上，
                        @Override
                        public void onAction(Context context, String item) {
                            LogUtils.d("itchen--itemLongClick-长按了图片--item="+item);

                            //打印出来的是图片的网址链接
                            //itchen---长按了图片--item=http://wuyeapi.91dgj.com/resource/ueditor/image/20190428/1556413817194059212.jpg
                            //长按让保存图片.这里暂时单一的就做个保存图片的功能
                            new MaterialDialog.Builder(mActivity)
                                    //.title("title7")// 标题
                                    .items(new String[]{"保存图片"})// 列表数据
                                    .itemsCallback(new MaterialDialog.ListCallback() {
                                        @Override
                                        public void onSelection(MaterialDialog dialog, View itemView, int position, CharSequence text) {

                                            downloadPresenter.tryDownload(item);
                                        }
                                    })
                                    .show();// 显示对话框
                            //原文：https://blog.csdn.net/x283930450/article/details/80525867

                        }
                    })*/
                    .checkable(false)//是否出现选择对勾内容//
                    .widget(Widget.newLightBuilder(mActivity)///
                            .statusBarColor(Color.WHITE)
                            .title(mActivity.getResources().getString(R.string.click_look_big_image))//
                            .build())
                    .onResult(new com.yanzhenjie.album.Action<ArrayList<String>>() {
                        @Override
                        public void onAction(@NonNull ArrayList<String> result) {
                            //
                        }
                    })
                    .start();//
        }

    }

    public static final LayoutInflater getLayoutInflater(Context _context) {

        // mLayoutInflater = LayoutInflater.from(context);
        LayoutInflater mLayoutInflater = (LayoutInflater) _context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);

        return mLayoutInflater;
    }

    //去掉首位，添加一个参数的内容，用在首页的扫码上。
    public static String splitFrontAndBehindAddOneParam(String _rqCode_content_param, String _appendsKey, String _appendsValue) {

//        传参的形式是：
//        {
//                "accessCode": 5808,
//                "spraySiteId": 4
//        }

        String splitFrontAndBehind = _rqCode_content_param.substring(1, _rqCode_content_param.length() - 1);

        //添加核销码字段拼接上
        StringBuffer stringBuffer = new StringBuffer();
        stringBuffer.append("{");
        stringBuffer.append(splitFrontAndBehind);//去掉第一位和最后一位的结果
        stringBuffer.append(",");//需要拼接成一个json，用逗号分割的
        stringBuffer.append("\"");//需要拼接成一个json，用逗号分割的
        stringBuffer.append(_appendsKey);//追加的内容,是键文本
        stringBuffer.append("\"");
        stringBuffer.append(":");
        stringBuffer.append("\"");//需要拼接成一个json，用逗号分割的
        stringBuffer.append(_appendsValue);//追加的内容,是值文本
        stringBuffer.append("\"");
        stringBuffer.append("}");

        LogUtils.d(ConstantSign.LOGCAT_NOMAL + "stringBuffer-->" + stringBuffer.toString());

        return stringBuffer.toString();

    }


    /**
     * 链接跳转的弹窗
     */
    public static void linkJumpDialog(Context mContext, Activity mActivity, String _contentResult) {

        new MaterialDialog.Builder(mContext)//
                .title("安全警告")//
                .content("该链接将跳转到外部页面，可能存在风险：" + _contentResult)//
                .positiveText("打开链接")//
                .negativeText("关闭")//
                .neutralText("复制链接")
                .onPositive(new MaterialDialog.SingleButtonCallback() {//
                    @Override
                    public void onClick(@NonNull MaterialDialog dialog, @NonNull DialogAction which) {

                        //弹窗其实是否打开链接
                        final Intent intent = new Intent();
                        intent.setAction(Intent.ACTION_VIEW);
                        intent.setData(Uri.parse(_contentResult));
                        // 注意此处的判断intent.resolveActivity()可以返回显示该Intent的Activity对应的组件名
                        // 官方解释 : Name of the component implementing an activity that can display the intent
                        if (intent.resolveActivity(mActivity.getPackageManager()) != null) {

                            //final ComponentName componentName = intent.resolveActivity(getPackageManager());
                            // 打印Log   ComponentName 到底是什么
                            //Log.e(TAG, "componentName = " + componentName.getClassName());

                            mActivity.startActivity(Intent.createChooser(intent, "请选择浏览器"));

                        } else {
                            ToastUtils.showShort("没有匹配的程序打开该链接");
                        }

                    }
                })
                .onNeutral(new MaterialDialog.SingleButtonCallback() {
                    @Override
                    public void onClick(@NonNull MaterialDialog dialog, @NonNull DialogAction which) {
                        //LogUtils.d("关闭弹窗");
                        methodCopyClip(_contentResult, true);
                    }
                })
                .onNegative(new MaterialDialog.SingleButtonCallback() {
                    @Override
                    public void onClick(@NonNull MaterialDialog dialog, @NonNull DialogAction which) {
                        methodCopyClip(_contentResult, true);
                    }
                })
                .cancelable(true)
                .show();//

    }

    /**
     * 2019年11月22日发现android4.4无法解决 raidioButton 和 checkBox 有左侧默认的方框的问题
     */
    public static void setButtonDrawable(CompoundButton _checkBox) {

        Bitmap bitmap = null;

        if (_checkBox != null) {
            _checkBox.setButtonDrawable(new BitmapDrawable(bitmap));
        }

    }

    /**
     * 使用添加字符串的时间的时候，使用【2020-10-27 09:09:19】格式接收，但是 只要日期，不要具体的时间 形如：【2020-10-27】
     * 本来不用封装，只有首页公告用到，但是后边陆续多用，就封装一个简略的。
     */
    public static String methodTimeCutIntoSections(Date timeReceive) {

        //Date timepresale = item.getStartTime();

        String finalStartTime = "";

        //内侧做判断，外侧可不做。
        if (!ObjectUtils.isEmpty(timeReceive)) {
            finalStartTime = TimeUtils.date2String(timeReceive, new SimpleDateFormat("yyyy-MM-dd"));
        } else {
            //这个时间段 设置为空。
            finalStartTime = "";
        }

        return finalStartTime;

    }

    //简短的弹窗提示
    public static void alertMaterialDialog(Activity _activity, String _title, String _content) {

        MaterialDialog materialDialog = new MaterialDialog.Builder(_activity)
                .title(_title)//
                .titleColor(ContextCompat.getColor(Utils.getApp(), R.color.dark))
                .content(_content)//
                .contentColor(ContextCompat.getColor(Utils.getApp(), R.color.gray19))
                .positiveText(_activity.getResources().getString(R.string.close_links_dialog_des))//关闭
                //.positiveColor(ContextCompat.getColor(Utils.getApp(), R.color.red_normal))
                //.negativeText("暂不更新")//
                //.negativeColor(ContextCompat.getColor(Utils.getApp(), R.color.colormobutton))
                .onPositive(new MaterialDialog.SingleButtonCallback() {//
                    @Override
                    public void onClick(MaterialDialog dialog, DialogAction which) {//
                        //仅仅是消失弹窗，暂时不做处理。
                    }
                }).canceledOnTouchOutside(true)//点击外侧不消失
                .show();

        materialDialog.getTitleView().setTextSize(16);

    }

    //设置文字图标的成功
    public static void setTextTips_success(Activity activity, TextView textView, String message) {

        if (textView != null) {
            textView.setVisibility(View.VISIBLE);


//            Drawable drawable = ResourcesCompat.getDrawable(activity.getResources(), R.drawable.icon_succesd, null);
////        drawable.setBounds(6, 0, 0, 0);
//            drawable.setBounds(0, 0, drawable.getMinimumWidth(), drawable.getMinimumHeight());
//            textView.setCompoundDrawables(drawable, null, null, null);
//            textView.setCompoundDrawablePadding(6);//设置图片和text之间的间距

            textView.setTextColor(ColorUtils.getColor(R.color.graycontent));
            textView.setText(activity.getResources().getString(R.string.text_choose_tips) + message);

        }

    }

    public static void setTextTips_fail(Activity activity, TextView textView, String message) {

        if (textView != null) {

            textView.setVisibility(View.VISIBLE);

//            Drawable drawable = ResourcesCompat.getDrawable(activity.getResources(), R.drawable.forbidde, null);
//            drawable.setBounds(0, 0, drawable.getMinimumWidth(), drawable.getMinimumHeight());
////          drawable.setBounds(6, 0, 0, 0);
//            textView.setCompoundDrawables(drawable, null, null, null);
//            textView.setCompoundDrawablePadding(6);//设置图片和text之间的间距

            textView.setTextColor(ColorUtils.getColor(R.color.redcomm));
            textView.setText(activity.getResources().getString(R.string.text_tips) + message);

        }


    }

    public static void myCustomMessageShow(Activity _activity, TextView textViewCardForbidden, String serverMessage) {

        if (!TextUtils.isEmpty(serverMessage)) {

            if (TextUtils.equals(serverMessage, _activity.getResources().getString(R.string.server_message_no_data))) {
                CommUtils.setTextTips_fail(_activity, textViewCardForbidden, _activity.getResources().getString(R.string.text_query_no_person));
            } else {
                CommUtils.setTextTips_fail(_activity, textViewCardForbidden, serverMessage);
            }

        } else {

            CommUtils.setTextTips_fail(_activity, textViewCardForbidden, _activity.getResources().getString(R.string.text_query_abnomal));

        }

    }

}
